Disco/Resources/Libraries/Spring.NET/Spring.Data.NHibernate21.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Spring.Data.NHibernate21</name>
    </assembly>
    <members>
        <member name="T:Spring.Data.NHibernate.Bytecode.BytecodeProvider">
            <summary>
            The Spring for .NET-backed ByteCodeprovider for NHibernate
            </summary>
            <author>Fabio Maulo</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.BytecodeProvider.#ctor(Spring.Objects.Factory.IListableObjectFactory)">
            <summary>
             Creates a new bytecode Provider instance using the specified object factory
            </summary>
            <param name="listableObjectFactory"></param>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.BytecodeProvider.GetReflectionOptimizer(System.Type,NHibernate.Properties.IGetter[],NHibernate.Properties.ISetter[])">
            <summary>
            Retrieve the <see cref="T:NHibernate.Bytecode.IReflectionOptimizer"/> delegate for this provider
                        capable of generating reflection optimization components.
            </summary>
            <param name="clazz">The class to be reflected upon.</param><param name="getters">All property getters to be accessed via reflection.</param><param name="setters">All property setters to be accessed via reflection.</param>
            <returns>The reflection optimization delegate.</returns>
        </member>
        <member name="P:Spring.Data.NHibernate.Bytecode.BytecodeProvider.ProxyFactoryFactory">
            <summary>
            The specific factory for this provider capable of 
            generating run-time proxies for lazy-loading purposes.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Bytecode.BytecodeProvider.ObjectsFactory">
            <summary>
            NHibernate's object instaciator.
            </summary>
            <remarks>
            For entities <see cref="T:NHibernate.Bytecode.IReflectionOptimizer"/> and its implementations.
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Bytecode.BytecodeProvider.CollectionTypeFactory">
            <summary>
            Instanciator of NHibernate's collections default types.
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.Bytecode.LazyInitializer">
            <summary>
            
            </summary>
            <author>Fabio Maulo</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.LazyInitializer.#ctor(System.String,System.Type,System.Object,System.Reflection.MethodInfo,System.Reflection.MethodInfo,NHibernate.Type.IAbstractComponentType,NHibernate.Engine.ISessionImplementor)">
            <summary>
            </summary>
            <param name="entityName"></param>
            <param name="persistentClass"></param>
            <param name="id"></param>
            <param name="getIdentifierMethod"></param>
            <param name="setIdentifierMethod"></param>
            <param name="componentIdType"></param>
            <param name="session"></param>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.LazyInitializer.Invoke(AopAlliance.Intercept.IMethodInvocation)">
            <summary>
            Implement this method to perform extra treatments before and after
            the call to the supplied <paramref name="invocation"/>.
            </summary>
            <remarks>
            <p>
            Polite implementations would certainly like to invoke
            <see cref="M:AopAlliance.Intercept.IJoinpoint.Proceed"/>. 
            </p>
            </remarks>
            <param name="invocation">
            The method invocation that is being intercepted.
            </param>
            <returns>
            The result of the call to the
            <see cref="M:AopAlliance.Intercept.IJoinpoint.Proceed"/> method of
            the supplied <paramref name="invocation"/>; this return value may
            well have been intercepted by the interceptor.
            </returns>
            <exception cref="T:System.Exception">
            If any of the interceptors in the chain or the target object itself
            throws an exception.
            </exception>
        </member>
        <member name="T:Spring.Data.NHibernate.Bytecode.ObjectsFactory">
            <summary>
            
            </summary>
            <author>Fabio Maulo</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ObjectsFactory.#ctor(Spring.Objects.Factory.IListableObjectFactory)">
            <summary>
            </summary>
            <param name="listableObjectFactory"></param>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ObjectsFactory.CreateInstance(System.Type)">
            <summary>
            Creates an instance of the specified type.
            </summary>
            <param name="type">The type of object to create.</param>
            <returns>A reference to the created object.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ObjectsFactory.CreateInstance(System.Type,System.Boolean)">
            <summary>
            Creates an instance of the specified type.
            </summary>
            <param name="type">The type of object to create.</param><param name="nonPublic">true if a public or nonpublic default constructor can match; false if only a public default constructor can match.</param>
            <returns>A reference to the created object </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ObjectsFactory.CreateInstance(System.Type,System.Object[])">
            <summary>
            Creates an instance of the specified type using the constructor that best matches the specified parameters.
            </summary>
            <param name="type">The type of object to create.</param><param name="ctorArgs">An array of constructor arguments.</param>
            <returns>A reference to the created object.</returns>
        </member>
        <member name="T:Spring.Data.NHibernate.Bytecode.ProxyFactory">
            <summary>
            A Spring for .NET backed <see cref="T:NHibernate.Proxy.IProxyFactory"/> implementation for creating
            NHibernate proxies.
            </summary>
            <seealso cref="T:Spring.Data.NHibernate.Bytecode.ProxyFactoryFactory"/>
            <author>Erich Eichinger</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ProxyFactory.GetProxy(System.Object,NHibernate.Engine.ISessionImplementor)">
            <summary>
            Creates a new proxy.
            </summary>
            <param name="id">The id value for the proxy to be generated.</param>
            <param name="session">The session to which the generated proxy will be associated.</param>
            <returns>The generated proxy.</returns>
            <exception cref="T:NHibernate.HibernateException">Indicates problems generating requested proxy.</exception>
        </member>
        <member name="T:Spring.Data.NHibernate.Bytecode.ProxyFactoryFactory">
            <summary>
            Creates a Spring for .NET backed <see cref="T:NHibernate.Proxy.IProxyFactory"/> instance.
            </summary>
            <author>Erich Eichinger</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ProxyFactoryFactory.BuildProxyFactory">
            <summary>
            Build a proxy factory specifically for handling runtime lazy loading. 
            </summary>
            <returns>The lazy-load proxy factory.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ProxyFactoryFactory.IsInstrumented(System.Type)">
            <summary>
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ProxyFactoryFactory.IsProxy(System.Object)">
            <summary>
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Bytecode.ProxyFactoryFactory.ProxyValidator">
            <summary>
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.Bytecode.ReflectionOptimizer">
            <summary>
            
            </summary>
            <author>Fabio Maulo</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ReflectionOptimizer.#ctor(Spring.Objects.Factory.IListableObjectFactory,System.Type,NHibernate.Properties.IGetter[],NHibernate.Properties.ISetter[])">
            <summary>
            </summary>
            <param name="listableObjectFactory"></param>
            <param name="mappedType"></param>
            <param name="getters"></param>
            <param name="setters"></param>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ReflectionOptimizer.CreateInstance">
            <summary>
            Perform instantiation of an instance of the underlying class.
            </summary>
            <returns>The new instance.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.Bytecode.ReflectionOptimizer.ThrowExceptionForNoDefaultCtor(System.Type)">
            <summary>
            
            </summary>
            <param name="type"></param>
        </member>
        <member name="T:Spring.Data.NHibernate.DelegatingLocalSessionFactoryObject">
            <summary>
             Delegates to an implementation of ISessionFactory that can select among multiple instances based on
             thread local storage.
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.LocalSessionFactoryObject">
            <summary>
             An IFactoryObject that creates a local Hibernate SessionFactory instance.
            Behaves like a SessionFactory instance when used as bean reference,
            e.g. for HibernateTemplate's "SessionFactory" property.
            </summary>
            <remarks>
            The typical usage will be to register this as singleton factory
            in an application context and give objects references to application services
            that need it.
            <para>
            Hibernate configuration settings can be set using the IDictionary property 'HibernateProperties'.
            </para>
            <para>
            This class implements the <see cref="T:Spring.Dao.Support.IPersistenceExceptionTranslator"/> interface,
            as autodetected by Spring's <see cref="T:Spring.Dao.Attributes.PersistenceExceptionTranslationPostProcessor"/>
            for AOP-based translation of PersistenceExceptionTranslationPostProcessor.
            Hence, the presence of e.g. LocalSessionFactoryBean automatically enables
            a PersistenceExceptionTranslationPostProcessor to translate Hibernate exceptions. 
            </para>
            </remarks>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.LocalSessionFactoryObject.log">
            <summary>
            The shared <see cref="T:Common.Logging.ILog"/> instance for this class (and derived classes).
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.LocalSessionFactoryObject"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.GetObject">
            <summary>
            Return the singleon session factory.
            </summary>
            <returns>The singleon session factory.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.AfterPropertiesSet">
            <summary>
            Initialize the SessionFactory for the given or the
            default location.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.Dispose">
            <summary>
            Close the SessionFactory on application context shutdown.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.NewConfiguration">
            <summary>
            Subclasses can override this method to perform custom initialization
            of the Configuration instance used for ISessionFactory creation.
            </summary>
            <remarks>
            The properties of this LocalSessionFactoryObject will be applied to
            the Configuration object that gets returned here.
            <p>The default implementation creates a new Configuration instance.
            A custom implementation could prepare the instance in a specific way,
            or use a custom Configuration subclass.
            </p>
            </remarks>
            <returns>The configuration instance.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.PostProcessMappings(NHibernate.Cfg.Configuration)">
            <summary>
            To be implemented by subclasses that want to to register further mappings
            on the Configuration object after this FactoryObject registered its specified
            mappings.
            </summary>
            <remarks>
            Invoked <i>before</i> the <code>BuildMappings</code> call,
            so that it can still extend and modify the mapping information.
            </remarks>
            <param name="config">the current Configuration object</param>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.PostProcessConfiguration(NHibernate.Cfg.Configuration)">
            <summary>
            To be implemented by subclasses that want to to perform custom
            post-processing of the Configuration object after this FactoryObject
            performed its default initialization.
            </summary>
            <param name="config">The current configuration object.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.AfterSessionFactoryCreation">
            <summary>
            Executes schema update if requested.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.DropDatabaseSchema">
            <summary>
            Execute schema drop script, determined by the Configuration object
            used for creating the SessionFactory. A replacement for NHibernate's
            SchemaExport class, to be invoked on application setup.
            </summary>
            <remarks>
            Fetch the LocalSessionFactoryBean itself rather than the exposed
            SessionFactory to be able to invoke this method, e.g. via
            <code>LocalSessionFactoryObject lsfb = (LocalSessionFactoryObject) ctx.GetObject("mySessionFactory");</code>.
            <p>
            Uses the SessionFactory that this bean generates for accessing a ADO.NET
            connection to perform the script.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.CreateDatabaseSchema">
            <summary>
            Execute schema creation script, determined by the Configuration object
            used for creating the SessionFactory. A replacement for NHibernate's
            SchemaExport class, to be invoked on application setup.
            </summary>
            <remarks>
            Fetch the LocalSessionFactoryObject itself rather than the exposed
            SessionFactory to be able to invoke this method, e.g. via
            <code>LocalSessionFactoryObject lsfo = (LocalSessionFactoryObject) ctx.GetObject("mySessionFactory");</code>.
            <p>
            Uses the SessionFactory that this bean generates for accessing a ADO.NET
            connection to perform the script.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.UpdateDatabaseSchema">
            <summary>
            Execute schema update script, determined by the Configuration object
            used for creating the SessionFactory. A replacement for NHibernate's
            SchemaUpdate class, for automatically executing schema update scripts
            on application startup. Can also be invoked manually.
            </summary>
            <remarks>
            Fetch the LocalSessionFactoryObject itself rather than the exposed
            SessionFactory to be able to invoke this method, e.g. via
            <code>LocalSessionFactoryObject lsfo = (LocalSessionFactoryObject) ctx.GetObject("mySessionFactory");</code>.
            <p>
            Uses the SessionFactory that this bean generates for accessing a ADO.NET
            connection to perform the script.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.ExecuteSchemaScript(System.Data.IDbConnection,System.String[])">
            <summary>
            Execute the given schema script on the given ADO.NET Connection.
            </summary>
            <remarks>
            Note that the default implementation will log unsuccessful statements
            and continue to execute. Override the <code>ExecuteSchemaStatement</code>
            method to treat failures differently.
            </remarks>
            <param name="con">The connection to use.</param>
            <param name="sql">The SQL statement to execute.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.ExecuteSchemaStatement(System.Data.IDbCommand,System.String)">
            <summary>
            Execute the given schema SQL on the given ADO.NET command.
            </summary>
            <remarks>
            Note that the default implementation will log unsuccessful statements
            and continue to execute. Override this method to treat failures differently.
            </remarks>
            <param name="cmd"></param>
            <param name="sql"></param>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.NewSessionFactory(NHibernate.Cfg.Configuration)">
            <summary>
            Subclasses can override this method to perform custom initialization
            of the SessionFactory instance, creating it via the given Configuration
            object that got prepared by this LocalSessionFactoryObject.
            </summary>
            <remarks>
            <p>The default implementation invokes Configuration's BuildSessionFactory.
            A custom implementation could prepare the instance in a specific way,
            or use a custom ISessionFactory subclass.
            </p>
            </remarks>
            <returns>The ISessionFactory instance.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.TranslateExceptionIfPossible(System.Exception)">
            <summary>
            Implementation of the PersistenceExceptionTranslator interface,
            as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.
            Converts the exception if it is a HibernateException;
            else returns <code>null</code> to indicate an unknown exception.
            translate the given exception thrown by a persistence framework to a
            corresponding exception from Spring's generic DataAccessException hierarchy,
            if possible.
            </summary>
            <param name="ex">The exception thrown.</param>
            <returns>
            the corresponding DataAccessException (or <code>null</code> if the
            exception could not be translated.
            </returns>
            <seealso cref="T:Spring.Dao.Attributes.PersistenceExceptionTranslationPostProcessor"/>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.ConvertHibernateException(NHibernate.HibernateException)">
            <summary>
            Convert the given HibernateException to an appropriate exception from the
            Spring's DAO Exception hierarchy.
            Will automatically apply a specified IAdoExceptionTranslator to a
            Hibernate ADOException, else rely on Hibernate's default translation.
            </summary>
            <param name="ex">The Hibernate exception that occured.</param>
            <returns>A corresponding DataAccessException</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.LocalSessionFactoryObject.ConvertAdoAccessException(NHibernate.ADOException)">
            <summary>
            Converts the ADO.NET access exception to an appropriate exception from the
            <code>org.springframework.dao</code> hierarchy. Can be overridden in subclasses.
            </summary>
            <param name="ex">ADOException that occured, wrapping underlying ADO.NET exception.</param>
            <returns>
            the corresponding DataAccessException instance
            </returns>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.ApplicationContext">
            <summary>
            Setting the Application Context determines were resources are loaded from
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.ResourceLoader">
            <summary>
            Gets or sets the <see cref="T:Spring.Core.IO.IResourceLoader"/> to use for loading mapping assemblies etc.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.MappingAssemblies">
            <summary>
            Sets the assemblies to load that contain mapping files.
            </summary>
            <value>The mapping assemblies.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.ConfigFilenames">
            <summary>
            Sets the hibernate configuration files to load, i.e. hibernate.cfg.xml.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.MappingResources">
            <summary>
            Sets the locations of Spring IResources that contain mapping
            files.
            </summary>
            <value>The location of mapping resources.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.Configuration">
            <summary>
            Return the Configuration object used to build the SessionFactory.
            Allows access to configuration metadata stored there (rarely needed).
            </summary>
            <value>The hibernate configuration.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.HibernateProperties">
            <summary>
            Set NHibernate configuration properties, like "hibernate.dialect".
            </summary>
            <value>The hibernate properties.</value>
            <remarks>
            	<p>Can be used to override values in a NHibernate XML config file,
            or to specify all necessary properties locally.
            </p>
            	<p>Note: Do not specify a transaction provider here when using
            Spring-driven transactions. It is also advisable to omit connection
            provider settings and use a Spring-set IDbProvider instead.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.DbProvider">
            <summary>
            Get or set the DataSource to be used by the SessionFactory.
            </summary>
            <value>The db provider.</value>
            <remarks>
            If set, this will override corresponding settings in Hibernate properties.
            <note>Note: If this is set, the Hibernate settings should not define
            a connection string
            (hibernate.connection.connection_string) to avoid meaningless double configuration.
            </note>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.ExposeTransactionAwareSessionFactory">
            <summary>
            Gets or sets a value indicating whether to expose a transaction aware session factory.
            </summary>
            <value>
            	<c>true</c> if want to expose transaction aware session factory; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.EntityInterceptor">
            <summary>
            Set a NHibernate entity interceptor that allows to inspect and change
            property values before writing to and reading from the database.
            Will get applied to any new Session created by this factory.
            <p>Such an interceptor can either be set at the SessionFactory level, i.e. on
            LocalSessionFactoryObject, or at the Session level, i.e. on HibernateTemplate,
            HibernateInterceptor, and HibernateTransactionManager. It's preferable to set
            it on LocalSessionFactoryObject or HibernateTransactionManager to avoid repeated
            configuration and guarantee consistent behavior in transactions.</p>
            </summary>
            <seealso cref="P:Spring.Data.NHibernate.HibernateTemplate.EntityInterceptor"/>
            <seealso cref="P:Spring.Data.NHibernate.HibernateTransactionManager.EntityInterceptor"/>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.NamingStrategy">
            <summary>
            Set a Hibernate NamingStrategy for the SessionFactory, determining the
            physical column and table names given the info in the mapping document.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.TypeDefinitions">
            <summary>
            Specify the Hibernate type definitions to register with the SessionFactory,
            as Spring IObjectDefinition instances. This is an alternative to specifying
            &lt;typedef&gt; elements in Hibernate mapping files.
            <p>Unfortunately, Hibernate itself does not define a complete object that
            represents a type definition, hence the need for Spring's TypeDefinitionBean.</p>
            @see TypeDefinitionBean
            @see org.hibernate.cfg.Mappings#addTypeDef(String, String, java.util.Properties)
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.FilterDefinitions">
            <summary>
            Specify the NHibernate FilterDefinitions to register with the SessionFactory.
            This is an alternative to specifying &lt;filter-def&gt; elements in
            Hibernate mapping files.
            </summary>
            <remarks>
            Typically, the passed-in FilterDefinition objects will have been defined
            as Spring FilterDefinitionFactoryBeans, probably as inner beans within the
            LocalSessionFactoryObject definition.
            </remarks>
            <see cref="T:Spring.Data.NHibernate.FilterDefinitionFactoryObject"/>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.EntityCacheStrategies">
            <summary>
            Specify the cache strategies for entities (persistent classes or named entities).
            This configuration setting corresponds to the &lt;class-cache&gt; entry
            in the "hibernate.cfg.xml" configuration format.
            <p>For example:
            <pre>
            &lt;property name="entityCacheStrategies"&gt;
              &lt;props&gt;
                &lt;prop key="MyCompany.Customer"&gt;read-write&lt;/prop&gt;
                &lt;prop key="MyCompany.Product"&gt;read-only,myRegion&lt;/prop&gt;
              &lt;/props&gt;
            &lt;/property&gt;</pre>
            </p>
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.CollectionCacheStrategies">
            <summary>
            Specify the cache strategies for persistent collections (with specific roles).
            This configuration setting corresponds to the &lt;collection-cache&gt; entry
            in the "hibernate.cfg.xml" configuration format.
            <p>For example:
            <pre>
            &lt;property name="CollectionCacheStrategies"&gt;
              &lt;props&gt;
                &lt;prop key="MyCompany.Order.Items">read-write&lt;/prop&gt;
                &lt;prop key="MyCompany.Product.Categories"&gt;read-only,myRegion&lt;/prop&gt;
              &lt;/props&gt;
            &lt;/property&gt;</pre>
            </p>
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.EventListeners">
            <summary>
            Specify the NHibernate event listeners to register, with listener types
            as keys and listener objects as values.
            <p>
            Instead of a single listener object, you can also pass in a list
            or set of listeners objects as value.
            </p>
            </summary>
            <value>listener objects as values</value>
            <remarks>
            See the NHibernate documentation for further details on listener types
            and associated listener interfaces.
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.SchemaUpdate">
            <summary>
            Set whether to execute a schema update after SessionFactory initialization.
            <p>
            For details on how to make schema update scripts work, see the NHibernate
            documentation, as this class leverages the same schema update script support
            in <see cref="P:Spring.Data.NHibernate.LocalSessionFactoryObject.Configuration"/> as NHibernate's own SchemaUpdate tool.
            </p>
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.AdoExceptionTranslator">
            <summary>
            Set the ADO.NET exception translator for this instance.
            Applied to System.Data.Common.DbException (or provider specific exception type
            in .NET 1.1) thrown by callback code, be it direct
            DbException or wrapped Hibernate ADOExceptions.
            <p>The default exception translator is either a ErrorCodeExceptionTranslator
            if a DbProvider is available, or a FalbackExceptionTranslator otherwise
            </p>
            </summary>
            <value>The ADO exception translator.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.BytecodeProvider">
            <summary>
            Sets custom byte code provider implementation to be used. This corresponds to setting
            the <see cref="P:NHibernate.Cfg.Environment.BytecodeProvider"/> property before NHibernate session factory
            configuration.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.ObjectType">
            <summary>
            Return the type <see cref="T:NHibernate.ISessionFactory"/> or subclass.
            </summary>
            <value>The type created by this factory</value>
        </member>
        <member name="P:Spring.Data.NHibernate.LocalSessionFactoryObject.IsSingleton">
            <summary>
            Returns true
            </summary>
            <value>true</value>
        </member>
        <member name="M:Spring.Data.NHibernate.DelegatingLocalSessionFactoryObject.NewSessionFactory(NHibernate.Cfg.Configuration)">
            <summary>
            Subclasses can override this method to perform custom initialization
            of the SessionFactory instance, creating it via the given Configuration
            object that got prepared by this LocalSessionFactoryObject.
            </summary>
            <remarks>
            <p>The default implementation invokes Configuration's BuildSessionFactory.
            A custom implementation could prepare the instance in a specific way,
            or use a custom ISessionFactory subclass.
            </p>
            </remarks>
            <returns>The ISessionFactory instance.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.DelegatingLocalSessionFactoryObject.PostProcessConfiguration(NHibernate.Cfg.Configuration)">
            <summary>
            PostProcessConfiguration
            </summary>
            <param name="config"></param>
        </member>
        <member name="T:Spring.Data.NHibernate.DelegatingSessionFactory">
            <summary>
            DelegatingSessionFactory class
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateTxScopeTransactionManager">
            <summary>
            PlatformTransactionManager implementation for a single Hibernate SessionFactory.
            Binds a Hibernate Session from the specified factory to the thread, potentially
            allowing for one thread Session per factory
            </summary>
            <remarks>
            SessionFactoryUtils and HibernateTemplate are aware of thread-bound Sessions and participate in such
            transactions automatically. Using either of those is required for Hibernate
            access code that needs to support this transaction handling mechanism.
            <para>
            Supports custom isolation levels at the start of the transaction
            , and timeouts that get applied as appropriate
            Hibernate query timeouts. To support the latter, application code must either use
            <code>HibernateTemplate</code> (which by default applies the timeouts) or call
            <code>SessionFactoryUtils.applyTransactionTimeout</code> for each created
            Hibernate Query object.
            </para>
            <para>Note that you can specify a Spring IDbProvider instance which if shared with
            a corresponding instance of AdoTemplate will allow for mixing ADO.NET/NHibernate
            operations within a single transaction.</para>
            </remarks>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.objectFactory">
            <summary>
            Just needed for entityInterceptorBeanName. 
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateTxScopeTransactionManager"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.#ctor(NHibernate.ISessionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateTxScopeTransactionManager"/> class.
            </summary>
            <param name="sessionFactory">The session factory.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoGetTransaction">
            <summary>
            Return the current transaction object.
            </summary>
            <returns>The current transaction object.</returns>
            <exception cref="T:Spring.Transaction.CannotCreateTransactionException">
            If transaction support is not available.
            </exception>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of lookup or system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.IsExistingTransaction(System.Object)">
            <summary>
            Check if the given transaction object indicates an existing,
            i.e. already begun, transaction.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <returns>True if there is an existing transaction.</returns>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoBegin(System.Object,Spring.Transaction.ITransactionDefinition)">
            <summary>
            Begin a new transaction with the given transaction definition.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <param name="definition">
            <see cref="T:Spring.Transaction.ITransactionDefinition"/> instance, describing
            propagation behavior, isolation level, timeout etc.
            </param>
            <remarks>
            Does not have to care about applying the propagation behavior,
            as this has already been handled by this abstract manager.
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of creation or system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoSuspend(System.Object)">
            <summary>
            Suspend the resources of the current transaction.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <returns>
            An object that holds suspended resources (will be kept unexamined for passing it into
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoResume(System.Object,System.Object)"/>.)
            </returns>
            <remarks>
            Transaction synchronization will already have been suspended.
            </remarks>
            <exception cref="T:Spring.Transaction.IllegalTransactionStateException">
            If suspending is not supported by the transaction manager implementation.
            </exception>
            <exception cref="T:Spring.Transaction.TransactionException">
            in case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoResume(System.Object,System.Object)">
            <summary>
            Resume the resources of the current transaction.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <param name="suspendedResources">
            The object that holds suspended resources as returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoSuspend(System.Object)"/>.
            </param>
            <remarks>
            Transaction synchronization will be resumed afterwards.
            </remarks>
            <exception cref="T:Spring.Transaction.IllegalTransactionStateException">
            If suspending is not supported by the transaction manager implementation.
            </exception>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoCommit(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Perform an actual commit on the given transaction.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <remarks>
            <p>
            An implementation does not need to check the rollback-only flag.
            </p>
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoTxScopeCommit(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Does the tx scope commit.
            </summary>
            <param name="status">The status.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoRollback(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Perform an actual rollback on the given transaction.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <remarks>
            An implementation does not need to check the new transaction flag.
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoTxScopeRollback(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Does the tx scope rollback.
            </summary>
            <param name="status">The status.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoSetRollbackOnly(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Set the given transaction rollback-only. Only called on rollback
            if the current transaction takes part in an existing one.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoTxScopeSetRollbackOnly(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Does the tx scope set rollback only.
            </summary>
            <param name="status">The status.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.GetIDbTransaction(NHibernate.ITransaction)">
            <summary>
            Gets the ADO.NET IDbTransaction object from the NHibernate ITransaction object.
            </summary>
            <param name="hibernateTx">The hibernate transaction.</param>
            <returns>The ADO.NET transaction.  Null if could not get the transaction.  Warning
            messages will be logged in that case.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.ConvertHibernateAccessException(NHibernate.HibernateException)">
            <summary>
            Convert the given HibernateException to an appropriate exception from
            the Spring.Dao hierarchy. Can be overridden in subclasses.
            </summary>
            <param name="ex">The HibernateException that occured.</param>
            <returns>The corresponding DataAccessException instance</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.ConvertAdoAccessException(NHibernate.ADOException,Spring.Data.Support.IAdoExceptionTranslator)">
            <summary>
            Convert the given ADOException to an appropriate exception from the
            the Spring.Dao hierarchy. Can be overridden in subclasses.
            </summary>
            <param name="ex">The ADOException that occured, wrapping the underlying
            ADO.NET thrown exception.</param>
            <param name="translator">The translator to convert hibernate ADOExceptions.</param>
            <returns>
            The corresponding DataAccessException instance
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DoCleanupAfterCompletion(System.Object)">
            <summary>
            Cleanup resources after transaction completion.
            </summary>
            <param name="transaction">Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
            <remarks>
            <note>
            This implemenation unbinds the SessionFactory and 
            DbProvider from thread local storage and closes the 
            ISession.
            </note>
            	<p>
            Called after <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoCommit(Spring.Transaction.Support.DefaultTransactionStatus)"/>
            and
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoRollback(Spring.Transaction.Support.DefaultTransactionStatus)"/>
            execution on any outcome.
            </p>
            	<p>
            Should not throw any exceptions but just issue warnings on errors.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.AfterPropertiesSet">
            <summary>
            Invoked by an <see cref="T:Spring.Objects.Factory.IObjectFactory"/>
            after it has injected all of an object's dependencies.
            </summary>
            <remarks>
            <p>
            This method allows the object instance to perform the kind of
            initialization only possible when all of it's dependencies have
            been injected (set), and to throw an appropriate exception in the
            event of misconfiguration.
            </p>
            <p>
            Please do consult the class level documentation for the
            <see cref="T:Spring.Objects.Factory.IObjectFactory"/> interface for a
            description of exactly <i>when</i> this method is invoked. In
            particular, it is worth noting that the
            <see cref="T:Spring.Objects.Factory.IObjectFactoryAware"/>
            and <see cref="T:Spring.Context.IApplicationContextAware"/>
            callbacks will have been invoked <i>prior</i> to this method being
            called.
            </p>
            </remarks>
            <exception cref="T:System.ArgumentException">
            In the event of misconfiguration (such as the failure to set a
            required property) or if initialization fails.
            </exception>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DbProvider">
            <summary>
            Gets or sets the db provider.
            </summary>
            <value>The db provider.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.EntityInterceptor">
            <summary>
            Gets or sets a Hibernate entity interceptor that allows to inspect and change
            property values before writing to and reading from the database.
            When getting, return the current Hibernate entity interceptor, or <code>null</code> if none.
            </summary>
            <value>The entity interceptor.</value>
            <remarks>
            Resolves an entity interceptor object name via the object factory,
            if necessary.
            Will get applied to any new Session created by this transaction manager.
            Such an interceptor can either be set at the SessionFactory level,
            i.e. on LocalSessionFactoryObject, or at the Session level, i.e. on
            HibernateTemplate, HibernateInterceptor, and HibernateTransactionManager.
            It's preferable to set it on LocalSessionFactoryObject or HibernateTransactionManager
            to avoid repeated configuration and guarantee consistent behavior in transactions.
            </remarks>
            <exception cref="T:System.InvalidOperationException">If object factory is null and need to get entity interceptor via object name.</exception>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.EntityInterceptorObjectName">
            <summary>
            Sets the object name of a Hibernate entity interceptor that
            allows to inspect and change property values before writing to and reading from the database.
            </summary>
            <value>The name of the entity interceptor object.</value>
            <remarks>
            Will get applied to any new Session created by this transaction manager.
            <p>Requires the object factory to be known, to be able to resolve the object
            name to an interceptor instance on session creation. Typically used for
            prototype interceptors, i.e. a new interceptor instance per session.
            </p>
            	<p>Can also be used for shared interceptor instances, but it is recommended
            to set the interceptor reference directly in such a scenario.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.AdoExceptionTranslator">
            <summary>
            Gets or sets the ADO.NET exception translator for this transaction manager.
            </summary>
            <remarks>
            Applied to ADO.NET Exceptions (wrapped by Hibernate's ADOException)
            </remarks>
            <value>The ADO exception translator.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.DefaultAdoExceptionTranslator">
            <summary>
            Gets the default IAdoException translator, lazily creating it if nece
            </summary>
            <value>The default IAdoException translator.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.SessionFactory">
            <summary>
            Gets or sets the SessionFactory that this instance should manage transactions for.
            </summary>
            <value>The session factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.ResourceFactory">
            <summary>
            Gets the resource factory that this transaction manager operates on,
            For the HibenratePlatformTransactionManager this the SessionFactory
            </summary>
            <value>The SessionFactory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.AutodetectDbProvider">
            <summary>
            Set whether to autodetect a ADO.NET connection used by the Hibernate SessionFactory,
            if set via LocalSessionFactoryObject's <code>DbProvider</code>. Default is "true".
            </summary>
            <value>
            	<c>true</c> if [autodetect data source]; otherwise, <c>false</c>.
            </value>
            <remarks>
            	<p>Can be turned off to deliberately ignore an available IDbProvider,
            to not expose Hibernate transactions as ADO.NET transactions for that IDbProvider.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.ObjectFactory">
            <summary>
            The object factory just needs to be known for resolving entity interceptor
            It does not need to be set for any other mode of operation.
            </summary>
            <value>
            Owning <see cref="T:Spring.Objects.Factory.IObjectFactory"/>
            (may not be <see langword="null"/>). The object can immediately
            call methods on the factory.
            </value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTxScopeTransactionManager.HibernateTransactionObject.RollbackOnly">
            <summary>
            Return whether the transaction is internally marked as rollback-only.
            </summary>
            <value></value>
            <returns>True of the transaction is marked as rollback-only.</returns>
        </member>
        <member name="T:Spring.Data.NHibernate.SimpleDelegatingSessionFactory">
            <summary>
            SimpleDelegatingSessionFactory class
            </summary>
        </member>
        <member name="F:Spring.Data.NHibernate.SimpleDelegatingSessionFactory.CONNECTION_STRING">
            <summary>
            Connection string config element name
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.SimpleDelegatingSessionFactory.#ctor(NHibernate.Cfg.Configuration)">
            <summary>
            public Constructor
            </summary>
            <param name="defaultConfiguration"></param>
        </member>
        <member name="P:Spring.Data.NHibernate.SimpleDelegatingSessionFactory.TargetSessionFactory">
            <summary>
            TargetSessionFactory
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings">
            <summary>
            Holds the references and configuration settings for a <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> instance. 
            References are resolved by looking up the given object names in the root <see cref="T:Spring.Context.IApplicationContext"/> obtained by <see cref="M:Spring.Context.Support.ContextRegistry.GetContext"/>.
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.Support.SessionScopeSettings">
            <summary>
            Holds the references and configuration settings for a <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> instance.
            </summary>
        </member>
        <member name="F:Spring.Data.NHibernate.Support.SessionScopeSettings.SINGLESESSION_DEFAULT">
            <summary>
            Default value for <see cref="P:Spring.Data.NHibernate.Support.SessionScopeSettings.SingleSession"/> property.
            </summary>
        </member>
        <member name="F:Spring.Data.NHibernate.Support.SessionScopeSettings.FLUSHMODE_DEFAULT">
            <summary>
            Default value for <see cref="P:Spring.Data.NHibernate.Support.SessionScopeSettings.DefaultFlushMode"/> property.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScopeSettings.#ctor">
            <summary>
            Initialize a new instance of <see cref="T:Spring.Data.NHibernate.Support.SessionScopeSettings"/> with default values.
            </summary>
            <remarks>
            Calling this constructor from your derived class leaves <see cref="P:Spring.Data.NHibernate.Support.SessionScopeSettings.SessionFactory"/> and <see cref="P:Spring.Data.NHibernate.Support.SessionScopeSettings.EntityInterceptor"/>
            uninitialized. See <see cref="M:Spring.Data.NHibernate.Support.SessionScopeSettings.ResolveSessionFactory"/> and <see cref="M:Spring.Data.NHibernate.Support.SessionScopeSettings.ResolveEntityInterceptor"/> for more.
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScopeSettings.#ctor(NHibernate.ISessionFactory)">
            <summary>
            Initialize a new instance of <see cref="T:Spring.Data.NHibernate.Support.SessionScopeSettings"/> with the given sessionFactory 
            and default values for all other settings.
            </summary>
            <param name="sessionFactory">
            The <see cref="T:NHibernate.ISessionFactory"/> instance to be used for obtaining <see cref="T:NHibernate.ISession"/> instances.
            </param>
            <remarks>
            Calling this constructor marks all properties initialized.
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScopeSettings.#ctor(NHibernate.ISessionFactory,NHibernate.IInterceptor,System.Boolean,NHibernate.FlushMode)">
            <summary>
            Initialize a new instance of <see cref="T:Spring.Data.NHibernate.Support.SessionScopeSettings"/> with the given values and references.
            </summary>
            <param name="sessionFactory">
            The <see cref="T:NHibernate.ISessionFactory"/> instance to be used for obtaining <see cref="T:NHibernate.ISession"/> instances.
            </param>
            <param name="entityInterceptor">
            Specify the <see cref="T:NHibernate.IInterceptor"/> to be set on each session provided by the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> instance.
            </param>
            <param name="singleSession">
            Set whether to use a single session for each request. See <see cref="P:Spring.Data.NHibernate.Support.SessionScopeSettings.SingleSession"/> property for details.
            </param>
            <param name="defaultFlushMode">
            Specify the flushmode to be applied on each session provided by the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> instance.
            </param>
            <remarks>
            Calling this constructor marks all properties initialized.
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScopeSettings.ResolveEntityInterceptor">
            <summary>
            Override this method to resolve an <see cref="T:NHibernate.IInterceptor"/> instance according to your chosen strategy.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScopeSettings.ResolveSessionFactory">
            <summary>
            Override this method to resolve an <see cref="T:NHibernate.ISessionFactory"/> instance according to your chosen strategy.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScopeSettings.EntityInterceptor">
            <summary>
            Gets the configured <see cref="T:NHibernate.IInterceptor"/> instance to be used.
            </summary>
            <remarks>
            If the entity interceptor is not set by the constructor, this property calls 
            <see cref="M:Spring.Data.NHibernate.Support.SessionScopeSettings.ResolveEntityInterceptor"/> to obtain an instance. This allows derived classes to 
            override the behaviour of how to obtain the concrete <see cref="T:NHibernate.IInterceptor"/> instance.
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScopeSettings.SessionFactory">
            <summary>
            Gets the configured <see cref="T:NHibernate.ISessionFactory"/> instance to be used.
            </summary>
            <remarks>
            If this property is requested for the first time, <see cref="M:Spring.Data.NHibernate.Support.SessionScopeSettings.ResolveSessionFactory"/> is called. 
            This allows derived classes to override the behaviour of how to obtain the concrete <see cref="T:NHibernate.ISessionFactory"/> instance.
            </remarks>
            <exception cref="T:System.ArgumentException">If the <see cref="T:NHibernate.ISessionFactory"/> instance cannot be resolved.</exception>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScopeSettings.SingleSession">
            <summary>
             Set whether to use a single session for each request. Default is "true".
             If set to false, each data access operation or transaction will use
             its own session (like without Open Session in View). Each of those
             sessions will be registered for deferred close, though, actually
             processed at request completion.
             </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScopeSettings.DefaultFlushMode">
            <summary>
            Gets or Sets the flushmode to be applied on each newly created session.
            </summary>
            <remarks>
            This property defaults to <see cref="F:NHibernate.FlushMode.Never"/> to ensure that modifying objects outside the boundaries 
            of a transaction will not be persisted. It is recommended to not change this value but wrap any modifying operation
            within a transaction.
            </remarks>
        </member>
        <member name="F:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.DEFAULT_SESSION_FACTORY_OBJECT_NAME">
            <summary>
            The default session factory name to use when retrieving the Hibernate session factory from
            the root context.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.#ctor(System.Type)">
            <summary>
            Initializes a new <see cref="T:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings"/> instance.
            </summary>
            <param name="ownerType">The type, who's name will be used to prefix setting variables with</param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.#ctor(System.Type,System.String)">
            <summary>
            Initializes a new <see cref="T:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings"/> instance.
            </summary>
            <param name="ownerType">The type, who's name will be used to prefix setting variables with</param>
            <param name="sectionName">The configuration section to read setting variables from.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.#ctor(System.Type,Spring.Objects.Factory.Config.IVariableSource)">
            <summary>
            Initializes a new <see cref="T:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings"/> instance.
            </summary>
            <param name="ownerType">The type, who's name will be used to prefix setting variables with</param>
            <param name="variableSource">The variable source to obtain settings from.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.ResolveEntityInterceptor">
            <summary>
            Resolve the entityInterceptor by looking up <see cref="F:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.entityInterceptorObjectName"/> 
            in the root application context.
            </summary>
            <returns>The resolved <see cref="T:NHibernate.IInterceptor"/> instance or <see langword="null"/></returns>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.ResolveSessionFactory">
            <summary>
            Resolve the <see cref="T:NHibernate.ISessionFactory"/> by looking up <see cref="F:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings.sessionFactoryObjectName"/> 
            in the root application context.
            </summary>
            <returns>The resolved <see cref="T:NHibernate.ISessionFactory"/> instance or <see langword="null"/></returns>
        </member>
        <member name="T:Spring.Data.NHibernate.Support.HibernateDaoSupport">
            <summary>
             Convenient super class for Hibernate data access objects.
            </summary>
            <remarks>
            <para>Requires a SessionFactory to be set, providing a HibernateTemplate
             based on it to subclasses. Can alternatively be initialized directly with
            a HibernateTemplate, to reuse the latter's settings such as the SessionFactory,
             exception translator, flush mode, etc
            </para>
            This base call is mainly intended for HibernateTemplate usage.
            <para>
            This class will create its own HibernateTemplate if only a SessionFactory
            is passed in. The "allowCreate" flag on that HibernateTemplate will be "true"
            by default. A custom HibernateTemplate instance can be used through overriding
            <code>CreateHibernateTemplate</code>.
            </para>
            </remarks>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.HibernateDaoSupport.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.HibernateDaoSupport"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.HibernateDaoSupport.CreateHibernateTemplate(NHibernate.ISessionFactory)">
            <summary>
            Create a HibernateTemplate for the given ISessionFactory.
            </summary>
            <remarks>
            Only invoked if populating the DAO with a ISessionFactory reference!
            <p>Can be overridden in subclasses to provide a HibernateTemplate instance
            with different configuration, or a custom HibernateTemplate subclass.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.HibernateDaoSupport.CheckDaoConfig">
            <summary>
            Check if the hibernate template property has been set.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.HibernateDaoSupport.DoGetSession(System.Boolean)">
            <summary>
            Get a Hibernate Session, either from the current transaction or
            a new one. The latter is only allowed if "allowCreate" is true.
            </summary>
            <remarks>Note that this is not meant to be invoked from HibernateTemplate code
            but rather just in plain Hibernate code. Either rely on a thread-bound
            Session (via HibernateInterceptor), or use it in combination with
            ReleaseSession.
            <para>
            In general, it is recommended to use HibernateTemplate, either with
            the provided convenience operations or with a custom HibernateCallback
            that provides you with a Session to work on. HibernateTemplate will care
            for all resource management and for proper exception conversion.
            </para>
            </remarks>
            <param name="allowCreate"> if a non-transactional Session should be created when no
            transactional Session can be found for the current thread
            </param>
            <returns>Hibernate session.</returns>
            <exception cref="T:Spring.Dao.DataAccessResourceFailureException">
            If the Session couldn't be created
            </exception>
            <exception cref="T:System.InvalidOperationException">
            if no thread-bound Session found and allowCreate false
            </exception>
            <seealso cref="M:Spring.Data.NHibernate.Support.HibernateDaoSupport.ReleaseSession(NHibernate.ISession)"/>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.HibernateDaoSupport.ConvertHibernateAccessException(NHibernate.HibernateException)">
            <summary>
            Convert the given HibernateException to an appropriate exception from the
            <code>org.springframework.dao</code> hierarchy. Will automatically detect
            wrapped ADO.NET Exceptions and convert them accordingly.
            </summary>
            <param name="ex">HibernateException that occured.</param>
            <returns>
            The corresponding DataAccessException instance
            </returns>
            <remarks>
            The default implementation delegates to SessionFactoryUtils
            and convertAdoAccessException. Can be overridden in subclasses.
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.HibernateDaoSupport.ReleaseSession(NHibernate.ISession)">
            <summary>
            Close the given Hibernate Session, created via this DAO's SessionFactory,
            if it isn't bound to the thread.
            </summary>
            <remarks>
            Typically used in plain Hibernate code, in combination with the 
            Session property and ConvertHibernateAccessException.
            </remarks>      
            <param name="session">The session to close.</param>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.HibernateDaoSupport.HibernateTemplate">
            <summary>
            Gets or sets the hibernate template.
            </summary>
            <remarks>Set the HibernateTemplate for this DAO explicitly,
            as an alternative to specifying a SessionFactory.
            </remarks>
            <value>The hibernate template.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.HibernateDaoSupport.SessionFactory">
            <summary>
            Gets or sets the session factory to be used by this DAO.
            Will automatically create a HibernateTemplate for the given SessionFactory.
            </summary>
            <value>The session factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.HibernateDaoSupport.Session">
            <summary>
            Get a Hibernate Session, either from the current transaction or a new one.
            The latter is only allowed if the "allowCreate" setting of this object's
            HibernateTemplate is true.
            </summary>
            <remarks>
            <p><b>Note that this is not meant to be invoked from HibernateTemplate code
            but rather just in plain Hibernate code.</b> Use it in combination with
            <b>ReleaseSession</b>.
            </p>
            <p>In general, it is recommended to use HibernateTemplate, either with
            the provided convenience operations or with a custom HibernateCallback
            that provides you with a Session to work on. HibernateTemplate will care
            for all resource management and for proper exception conversion.
            </p>
            </remarks>
            <value>The Hibernate session.</value>
        </member>
        <member name="T:Spring.Data.NHibernate.Support.OpenSessionInViewModule">
            <summary>
            Provide support for the open session in view pattern for lazily loaded hibernate objects
            used in ASP.NET pages.
            </summary>
            <author>jjx: http://forum.springframework.net/member.php?u=29</author>
            <author>Mark Pollack (.NET)</author>
            <author>Erich Eichinger</author>
            <author>Harald Radi</author>
        </member>
        <member name="T:Spring.Data.NHibernate.Support.SessionScope">
            <summary>
            Implementation of SessionScope that associates a single session within the using scope.
            </summary>
            <remarks>
            <para>It is recommended to be used in the following type of scenario:
            <code>
            using (new SessionScope())
            {
               ... do multiple operation, possibly in multiple transactions. 
            }
            </code>
            At the end of "using", the session is automatically closed. All transactions within the scope use the same session,
            if you are using Spring's HibernateTemplate or using Spring's implementation of NHibernate 1.2's 
            ICurrentSessionContext interface.  
            </para>
            <para>
            It is assumed that the session factory object name is called "SessionFactory". In case that you named the object 
            in different way you can specify your can specify it in the application settings using the key
            Spring.Data.NHibernate.Support.SessionScope.SessionFactoryObjectName.  Values for EntityInterceptorObjectName
            and SingleSessionMode can be specified similarly.
            </para>
            <para>
            <b>Note:</b>
            The session is managed on a per thread basis on the thread that opens the scope instance. This means that you must
            never pass a reference to a <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> instance over to another thread!
            </para>
            </remarks>
            <author>Robert M. (.NET)</author>
            <author>Harald Radi (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.Support.SessionScope.log">
            <summary>
            The logging instance.
            </summary>        
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> class in single session mode, 
            associating a session with the thread.  The session is opened lazily on demand.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> class.
            </summary>
            <param name="open">
            If set to <c>true</c> associate a session with the thread.  If false, another
            collaborating class will associate the session with the thread, potentially by calling
            the Open method on this class.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.#ctor(System.String,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> class.
            </summary>
            <param name="sectionName">
            The name of the configuration section to read configuration settings from. 
            See <see cref="T:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings"/> for more info.
            </param>
            <param name="open">
            If set to <c>true</c> associate a session with the thread.  If false, another
            collaborating class will associate the session with the thread, potentially by calling
            the Open method on this class.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.#ctor(System.String,System.Type,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> class.
            </summary>
            <param name="sectionName">
            The name of the configuration section to read configuration settings from. 
            See <see cref="T:Spring.Data.NHibernate.Support.ConfigSectionSessionScopeSettings"/> for more info.
            </param>
            <param name="namespaceType">The type, who's full name is used for prefixing appSetting keys</param>
            <param name="open">
            If set to <c>true</c> associate a session with the thread.  If false, another
            collaborating class will associate the session with the thread, potentially by calling
            the Open method on this class.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.#ctor(NHibernate.ISessionFactory,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> class.
            </summary>
            <param name="sessionFactory">
            The <see cref="T:NHibernate.ISessionFactory"/> instance to be used for obtaining <see cref="T:NHibernate.ISession"/> instances.
            </param>
            <param name="open">
            If set to <c>true</c> associate a session with the thread.  If false, another
            collaborating class will associate the session with the thread, potentially by calling
            the Open method on this class.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.#ctor(NHibernate.ISessionFactory,NHibernate.IInterceptor,System.Boolean,NHibernate.FlushMode,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> class.
            </summary>
            <param name="sessionFactory">
            The <see cref="T:NHibernate.ISessionFactory"/> instance to be used for obtaining <see cref="T:NHibernate.ISession"/> instances.
            </param>
            <param name="entityInterceptor">
            Specify the <see cref="T:NHibernate.IInterceptor"/> to be set on each session provided by this <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> instance.
            </param>
            <param name="singleSession">
            Set whether to use a single session for each request. See <see cref="P:Spring.Data.NHibernate.Support.SessionScope.SingleSession"/> property for details.
            </param>
            <param name="defaultFlushMode">
            Specify the flushmode to be applied on each session provided by this <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> instance.
            </param>
            <param name="open">
            If set to <c>true</c> associate a session with the thread.  If false, another
            collaborating class will associate the session with the thread, potentially by calling
            the Open method on this class.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.#ctor(Spring.Data.NHibernate.Support.SessionScopeSettings,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.SessionScope"/> class.
            </summary>
            <param name="settings">An <see cref="T:Spring.Data.NHibernate.Support.SessionScopeSettings"/> instance holding the scope configuration</param>
            <param name="open">
            If set to <c>true</c> associate a session with the thread.  If false, another
            collaborating class will associate the session with the thread, potentially by calling
            the Open method on this class.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.SetOpen(System.Boolean)">
            <summary>
            Sets a flag, whether this scope is in "open" state on the current logical thread.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.SetParticipating(System.Boolean)">
            <summary>
            Gets/Sets a flag, whether this scope manages it's own session for the current logical thread or not.
            </summary>
            <value><c>false</c> if session is managed by this module. <c>false</c> otherwise</value>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.Dispose">
            <summary>
            Call <code>Close()</code>, 
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.Open">
            <summary>
            Opens a new session or participates in an existing session and 
            registers with spring's <see cref="T:Spring.Transaction.Support.TransactionSynchronizationManager"/>.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.Close">
            <summary>
            Close the current view's session and unregisters 
            from spring's <see cref="T:Spring.Transaction.Support.TransactionSynchronizationManager"/>.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScope.SingleSession">
            <summary>
            Set whether to use a single session for each request. Default is "true".
            If set to false, each data access operation or transaction will use
            its own session (like without Open Session in View). Each of those
            sessions will be registered for deferred close, though, actually
            processed at request completion.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScope.DefaultFlushMode">
            <summary>
            Gets the flushmode to be applied on each newly created session.
            </summary>
            <remarks>
            This property defaults to <see cref="F:NHibernate.FlushMode.Never"/> to ensure that modifying objects outside the boundaries 
            of a transaction will not be persisted. It is recommended to not change this value but wrap any modifying operation
            within a transaction.
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScope.SessionFactory">
            <summary>
            Get or set the configured SessionFactory
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScope.EntityInterceptor">
            <summary>
            Get or set the configured EntityInterceptor
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScope.IsOpen">
            <summary>
            Gets a flag, whether this scope is in "open" state on the current logical thread.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.Support.SessionScope.IsParticipating">
            <summary>
            Gets a flag, whether this scope manages it's own session for the current logical thread or not.
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.Support.SessionScope.LazySessionHolder">
            <summary>
            This sessionHolder creates a default session only if it is needed.
            </summary>
            <remarks>
            Although a NHibernateSession deferes creation of db-connections until they are really
            needed, instantiation a session is imho still more expensive than this LazySessionHolder. (EE)
            </remarks>
        </member>
        <member name="T:Spring.Data.NHibernate.SessionHolder">
            <summary>
            Session holder, wrapping a NHibernate ISession and a NHibernate Transaction.
            HibernateTransactionManager binds instances of this class
            to the thread, for a given ISessionFactory.
            </summary>
            <remarks>
            Note: This is an SPI class, not intended to be used by applications.
            </remarks>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.#ctor">
            <summary>
            May be used by derived classes to create an empty SessionHolder.
            </summary>
            <remarks>
            When using this ctor in your derived class, you MUST override <see cref="M:Spring.Data.NHibernate.SessionHolder.EnsureInitialized"/>!
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.#ctor(NHibernate.ISession)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.SessionHolder"/> class.
            </summary>
            <param name="session">The session.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.#ctor(System.Object,NHibernate.ISession)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.SessionHolder"/> class.
            </summary>
            <param name="key">The key to store the session under.</param>
            <param name="session">The hibernate session.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.EnsureInitialized">
            <summary>
            May be overridden in a derived class to e.g. lazily create a session
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.GetSession(System.Object)">
            <summary>
            Gets the session given key identifier
            </summary>
            <param name="key">The key.</param>
            <returns>A hibernate session</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.GetValidatedSession(System.Object)">
            <summary>
            Gets the session given the key and removes the session from
            the dictionary storage.
            </summary>
            <param name="key">The key.</param>
            <returns>A hibernate session</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.AddSession(NHibernate.ISession)">
            <summary>
            Adds the session to the dictionary storage using the default key.
            </summary>
            <param name="session">The hibernate session.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.AddSession(System.Object,NHibernate.ISession)">
            <summary>
            Adds the session to the dictionary storage using the supplied key.
            </summary>
            <param name="key">The key.</param>
            <param name="session">The hibernate session.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.RemoveSession(System.Object)">
            <summary>
            Removes the session from the dictionary storage for the given key.
            </summary>
            <param name="key">The key.</param>
            <returns>The session that was previously contained in the
            dictionary storage.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.ContainsSession(System.Object)">
            <summary>
            Determines whether the holder the specified session.
            </summary>
            <param name="session">The session.</param>
            <returns>
            	<c>true</c> if the holder contains the specified session; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionHolder.Clear">
            <summary>
            Clear the transaction state of this resource holder.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.Session">
            <summary>
            Gets the session using the default key
            </summary>
            <value>The hibernate session.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.AnySession">
            <summary>
            Gets the first session based on iteration over
            the IDictionary storage.
            </summary>
            <value>Any hibernate session.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.IsEmpty">
            <summary>
            Gets a value indicating whether dictionary of
            hibernate sessions is empty.
            </summary>
            <value>
            	<c>true</c> if this session holder is empty; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.DoesNotHoldNonDefaultSession">
            <summary>
            Gets a value indicating whether this SessionHolder
            does not hold non default session.
            </summary>
            <value>
            	<c>true</c> if does not hold non default session; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.Transaction">
            <summary>
            Gets or sets the hibernate transaction.
            </summary>
            <value>The transaction.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.Connection">
            <summary>
            Gets or sets the ADO.NET Connection used to create the session.
            </summary>
            <value>The ADO.NET connection.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.PreviousFlushMode">
            <summary>
            Gets or sets the previous flush mode.
            </summary>
            <value>The previous flush mode.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.AssignedPreviousFlushMode">
            <summary>
            Gets a value indicating whether the PreviousFlushMode property
            was set.
            </summary>
            <value>
            	<c>true</c> if assigned PreviousFlushMode property; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Data.NHibernate.SessionHolder.ValidatedSession">
            <summary>
            Gets the validated session.
            </summary>
            <value>The validated session.</value>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.LazySessionHolder.#ctor(Spring.Data.NHibernate.Support.SessionScope)">
            <summary>
            Initialize a new instance.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.LazySessionHolder.EnsureInitialized">
            <summary>
            Create a new session on demand
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.SessionScope.LazySessionHolder.Close">
            <summary>
            Ensure session is closed (if any) and remove circular references to avoid memory leaks!
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.OpenSessionInViewModule.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Support.OpenSessionInViewModule"/> class.  Creates a SessionScope,
            but does not yet associate a session with a thread, that is left to the lifecycle of the request.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.OpenSessionInViewModule.Init(System.Web.HttpApplication)">
            <summary>
            Register context handler and look up SessionFactoryObjectName under the application configuration key,
            Spring.Data.NHibernate.Support.OpenSessionInViewModule.SessionFactoryObjectName if not using the default value
            (i.e. sessionFactory) and look up the SingleSession setting under the application configuration key,
            Spring.Data.NHibernate.Support.OpenSessionInViewModule.SingleSession if not using the default value of true.
            </summary>
            <param name="context">The standard HTTP application context</param>
        </member>
        <member name="M:Spring.Data.NHibernate.Support.OpenSessionInViewModule.Dispose">
            <summary>
            A do nothing dispose method.
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateAdoException">
            <summary>
            Hibernate-specific subclass of UncategorizedDataAccessException,
            for ADO.NET exceptions that Hibernate rethrew and could not be
            mapped into the DAO exception heirarchy.
            </summary>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAdoException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateAdoException"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAdoException.#ctor(System.String)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateAdoException"/> class.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAdoException.#ctor(System.String,NHibernate.ADOException)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateAdoException"/> class.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception from the underlying data access API - ADO.NET
            </param>        
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAdoException.#ctor(System.String,System.Exception)">
            <summary>
            Creates a new instance of the HibernateSystemException class with the specified message
            and root cause.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception that is being wrapped.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAdoException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateAdoException"/> class.
            </summary>
            <param name="info">
            The <see cref="T:System.Runtime.Serialization.SerializationInfo"/>
            that holds the serialized object data about the exception being thrown.
            </param>
            <param name="context">
            The <see cref="T:System.Runtime.Serialization.StreamingContext"/>
            that contains contextual information about the source or destination.
            </param>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateDelegate">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateQueryException">
            <summary>
            Hibernate-specific subclass of InvalidDataAccessResourceUsageException,
            thrown on invalid HQL query syntax.
            </summary>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateQueryException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateQueryException"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateQueryException.#ctor(System.String)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateQueryException"/> class.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateQueryException.#ctor(NHibernate.QueryException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateQueryException"/> class.
            </summary>
            <param name="ex">The ex.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateQueryException.#ctor(System.String,System.Exception)">
            <summary>
            Creates a new instance of the HibernateQueryException class with the specified message
            and root cause.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception that is being wrapped.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateQueryException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateQueryException"/> class.
            </summary>
            <param name="info">
            The <see cref="T:System.Runtime.Serialization.SerializationInfo"/>
            that holds the serialized object data about the exception being thrown.
            </param>
            <param name="context">
            The <see cref="T:System.Runtime.Serialization.StreamingContext"/>
            that contains contextual information about the source or destination.
            </param>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateQueryException.QueryString">
            <summary>
            Gets the query string that was invalid.
            </summary>
            <value>The query string that was invalid.</value>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateSystemException">
            <summary>
            Hibernate-specific subclass of UncategorizedDataAccessException,
            for Hibernate system errors that do not match any concrete
            <code>Spring.Dao</code> exceptions.
            </summary>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateSystemException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateSystemException"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateSystemException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateSystemException"/> class.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateSystemException.#ctor(System.String,System.Exception)">
            <summary>
            Creates a new instance of the HibernateSystemException class with the specified message
            and root cause.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception that is being wrapped.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateSystemException.#ctor(NHibernate.HibernateException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateSystemException"/> class.
            </summary>
            <param name="cause">The cause.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateSystemException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateSystemException"/> class.
            </summary>
            <param name="info">
            The <see cref="T:System.Runtime.Serialization.SerializationInfo"/>
            that holds the serialized object data about the exception being thrown.
            </param>
            <param name="context">
            The <see cref="T:System.Runtime.Serialization.StreamingContext"/>
            that contains contextual information about the source or destination.
            </param>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateTemplate">
             <summary>
             Helper class that simplifies NHibernate data access code
             </summary>
             <remarks>
             <p>Typically used to implement data access or business logic services that
             use NHibernate within their implementation but are Hibernate-agnostic in their
             interface. The latter or code calling the latter only have to deal with
             domain objects.</p>
            
             <p>The central method is Execute supporting Hibernate access code
             implementing the HibernateCallback interface. It provides NHibernate Session
             handling such that neither the IHibernateCallback implementation nor the calling
             code needs to explicitly care about retrieving/closing NHibernate Sessions,
             or handling Session lifecycle exceptions. For typical single step actions,
             there are various convenience methods (Find, Load, SaveOrUpdate, Delete).
             </p>
             
             <p>Can be used within a service implementation via direct instantiation
             with a ISessionFactory reference, or get prepared in an application context
             and given to services as an object reference. Note: The ISessionFactory should
             always be configured as an object in the application context, in the first case
             given to the service directly, in the second case to the prepared template.
             </p>
             
             <p>This class can be considered as direct alternative to working with the raw
             Hibernate Session API (through SessionFactoryUtils.Session).
             </p>
             
             <p>LocalSessionFactoryObject is the preferred way of obtaining a reference
             to a specific NHibernate ISessionFactory.
             </p>
             </remarks>
             <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateAccessor">
            <summary>
            Base class for HibernateTemplate defining common
            properties like SessionFactory and flushing behavior.
            </summary>
            <remarks>
            <p>Not intended to be used directly. See HibernateTemplate.
            </p>
            </remarks>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.HibernateAccessor.log">
            <summary>
            The <see cref="T:Common.Logging.ILog"/> instance for this class. 
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateAccessor"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.ApplyFlushMode(NHibernate.ISession,System.Boolean)">
            <summary>
            Apply the flush mode that's been specified for this accessor
            to the given Session.
            </summary>
            <param name="session">The current Hibernate Session.</param>
            <param name="existingTransaction">if set to <c>true</c>
            if executing within an existing transaction.</param>
            <returns>
            the previous flush mode to restore after the operation,
            or <code>null</code> if none
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.FlushIfNecessary(NHibernate.ISession,System.Boolean)">
            <summary>
             Flush the given Hibernate Session if necessary.
            </summary>
            <param name="session">The current Hibernate Session.</param>
            <param name="existingTransaction">if set to <c>true</c> 
            if executing within an existing transaction.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.ConvertHibernateAccessException(NHibernate.HibernateException)">
            <summary>
            Convert the given HibernateException to an appropriate exception from the
            <code>org.springframework.dao</code> hierarchy. Will automatically detect
            wrapped ADO.NET Exceptions and convert them accordingly.
            </summary>
            <param name="ex">HibernateException that occured.</param>
            <returns>
            The corresponding DataAccessException instance
            </returns>
            <remarks>
            The default implementation delegates to SessionFactoryUtils
            and convertAdoAccessException. Can be overridden in subclasses.
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.ConvertAdoAccessException(NHibernate.ADOException)">
            <summary>
            Converts the ADO.NET access exception to an appropriate exception from the
            <code>org.springframework.dao</code> hierarchy. Can be overridden in subclasses.
            </summary>
            <param name="ex">ADOException that occured, wrapping underlying ADO.NET exception.</param>
            <returns>
            the corresponding DataAccessException instance
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.ConvertAdoAccessException(System.Exception)">
            <summary>
            Converts the ADO.NET access exception to an appropriate exception from the
            <code>org.springframework.dao</code> hierarchy. Can be overridden in subclasses.
            </summary>
            <remarks>
            <note>
            Note that a direct SQLException can just occur when callback code
            performs direct ADO.NET access via <code>ISession.Connection()</code>.
            </note>
            </remarks>
            <param name="ex">The ADO.NET exception.</param>
            <returns>The corresponding DataAccessException instance</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.PrepareQuery(NHibernate.IQuery)">
            <summary>
            Prepare the given IQuery object, applying cache settings and/or
            a transaction timeout.
            </summary>
            <param name="queryObject">The query object to prepare.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.ApplyNamedParameterToQuery(NHibernate.IQuery,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Apply the given name parameter to the given Query object.
            </summary>
            <param name="queryObject">The query object.</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">The NHibernate type of the parameter (or <code>null</code> if none specified)</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.PrepareCriteria(NHibernate.ICriteria)">
            <summary>
            Prepare the given Criteria object, applying cache settings and/or
            a transaction timeout.
            </summary>
            <remarks>
            <para>Note that for NHibernate 1.2 this only works if the
            implementation is of the type CriteriaImpl, which should generally
            be the case.  The SetFetchSize method is not available on the
            ICriteria interface
            </para>
            <para>This is a no-op for NHibernate 1.0.x since
            the SetFetchSize method is not on the ICriteria interface and
            the implementation class is has internal access.
            </para>
            <para>To remove the method completely for Spring's NHibernate 1.0 
            support while reusing code for NHibernate 1.2 would not be 
            possible.  So now this ineffectual operation is left in tact for
            NHibernate 1.0.2 support.</para>
            </remarks>
            <param name="criteria">The criteria object to prepare</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.AfterPropertiesSet">
            <summary>
            Ensure SessionFactory is not null
            </summary>
            <exception cref="T:System.ArgumentException">If SessionFactory property is null.</exception>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.AllowCreate">
            <summary>
            Gets or sets if a new Session should be created when no transactional Session
            can be found for the current thread.
            </summary>
            <value>
            	<c>true</c> if allowed to create non-transaction session;
            otherwise, <c>false</c>.
            </value>
            <remarks>
            	<p>HibernateTemplate is aware of a corresponding Session bound to the
            current thread, for example when using HibernateTransactionManager.
            If allowCreate is true, a new non-transactional Session will be created
            if none found, which needs to be closed at the end of the operation.
            If false, an InvalidOperationException will get thrown in this case.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.AlwaysUseNewSession">
            <summary>
            Gets or sets a value indicating whether to always
            use a new Hibernate Session for this template.
            </summary>
            <value><c>true</c> if always use new session; otherwise, <c>false</c>.</value>
            <remarks>
            	<p>
            Default is "false"; if activated, all operations on this template will
            work on a new NHibernate ISession even in case of a pre-bound ISession
            (for example, within a transaction).
            </p>
            	<p>Within a transaction, a new NHibernate ISession used by this template
            will participate in the transaction through using the same ADO.NET
            Connection. In such a scenario, multiple Sessions will participate
            in the same database transaction.
            </p>
            	<p>Turn this on for operations that are supposed to always execute
            independently, without side effects caused by a shared NHibernate ISession.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.ExposeNativeSession">
            <summary>
            Set whether to expose the native Hibernate Session to IHibernateCallback
            code. Default is "false": a Session proxy will be returned,
            suppressing <code>close</code> calls and automatically applying
            query cache settings and transaction timeouts.
            </summary>
            <value><c>true</c> if expose native session; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.TemplateFlushMode">
            <summary>
            Gets or sets the template flush mode.
            </summary>
            <remarks>
            Default is Auto. Will get applied to any <b>new</b> ISession
            created by the template.
            </remarks>
            <value>The template flush mode.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.EntityInterceptor">
            <summary>
            Gets or sets the entity interceptor that allows to inspect and change
            property values before writing to and reading from the database.
            </summary>
            <remarks>
            Will get applied to any <b>new</b> ISession created by this object.
            <p>Such an interceptor can either be set at the ISessionFactory level,
            i.e. on LocalSessionFactoryObject, or at the ISession level, i.e. on
            HibernateTemplate, HibernateInterceptor, and HibernateTransactionManager.
            It's preferable to set it on LocalSessionFactoryObject or HibernateTransactionManager
            to avoid repeated configuration and guarantee consistent behavior in transactions.
            </p>
            </remarks>
            <value>The interceptor.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.EntityInterceptorObjectName">
            <summary>
            Set the object name of a Hibernate entity interceptor that allows to inspect
            and change property values before writing to and reading from the database.
            </summary>
            <remarks>
            Will get applied to any new Session created by this transaction manager.
            <p>Requires the object factory to be known, to be able to resolve the object
            name to an interceptor instance on session creation. Typically used for
            prototype interceptors, i.e. a new interceptor instance per session.
            </p>
            <p>Can also be used for shared interceptor instances, but it is recommended
            to set the interceptor reference directly in such a scenario.
            </p>
            </remarks>
            <value>The name of the entity interceptor in the object factory/application context.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.SessionFactory">
            <summary>
            Gets or sets the session factory that should be used to create
            NHibernate ISessions.
            </summary>
            <value>The session factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.ObjectFactory">
            <summary>
            Set the object factory instance.
            </summary>
            <value>The object factory instance.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.CacheQueries">
            <summary>
            Gets or sets a value indicating whether to 
            cache all queries executed by this template.
            </summary>
            <remarks>
            If this is true, all IQuery and ICriteria objects created by
            this template will be marked as cacheable (including all
            queries through find methods).
            <p>To specify the query region to be used for queries cached
            by this template, set the QueryCacheRegion property.
            </p>
            </remarks>
            <value><c>true</c> if cache queries; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.QueryCacheRegion">
            <summary>
            Gets or sets the name of the cache region for queries executed by this template.
            </summary>
            <remarks>
            If this is specified, it will be applied to all IQuery and ICriteria objects
            created by this template (including all queries through find methods).
            <p>The cache region will not take effect unless queries created by this
            template are configured to be cached via the CacheQueries property.
            </p>
            </remarks>
            <value>The query cache region.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.FetchSize">
            <summary>
            Gets or sets the fetch size for this HibernateTemplate.
            </summary>
            <value>The size of the fetch.</value>
            <remarks>This is important for processing
            large result sets: Setting this higher than the default value will increase
            processing speed at the cost of memory consumption; setting this lower can
            avoid transferring row data that will never be read by the application.
            <p>Default is 0, indicating to use the driver's default.</p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.MaxResults">
            <summary>
            Gets or sets the maximum number of rows for this HibernateTemplate.
            </summary>
            <value>The max results.</value>
            <remarks>
            This is important
            for processing subsets of large result sets, avoiding to read and hold
            the entire result set in the database or in the ADO.NET driver if we're
            never interested in the entire result in the first place (for example,
            when performing searches that might return a large number of matches).
            <p>Default is 0, indicating to use the driver's default.</p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.AdoExceptionTranslator">
            <summary>
            Set the ADO.NET exception translator for this instance.
            Applied to System.Data.Common.DbException (or provider specific exception type
            in .NET 1.1) thrown by callback code, be it direct
            DbException or wrapped Hibernate ADOExceptions.
            <p>The default exception translator is either a ErrorCodeExceptionTranslator
            if a DbProvider is available, or a FalbackExceptionTranslator otherwise
            </p>
            </summary>
            <value>The ADO exception translator.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.Session">
            <summary>
            Gets a Session for use by this template.
            </summary>
            <value>The session.</value>
            <remarks>
            - Returns a new Session in case of "alwaysUseNewSession" (using the same ADO.NET connection as a transaction Session, if applicable)
            - a pre-bound Session in case of "AllowCreate" is set to false (not the default) 
            - or a pre-bound Session or new Session if no transactional or other pre-bound Session exists.
            </remarks>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateAccessor.FlushModeHolder">
            <summary>
            Helper class to determine if the FlushMode enumeration
            was changed from its default value
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.FlushModeHolder.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateAccessor.FlushModeHolder"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateAccessor.FlushModeHolder.#ctor(NHibernate.FlushMode)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateAccessor.FlushModeHolder"/> class.
            </summary>
            <param name="mode">The flush mode.</param>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.FlushModeHolder.ModeWasSet">
            <summary>
            Gets or sets a value indicating whether the FlushMode
            property was set..
            </summary>
            <value><c>true</c> if FlushMode was set; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateAccessor.FlushModeHolder.Mode">
            <summary>
            Gets or sets the FlushMode.
            </summary>
            <value>The FlushMode.</value>
        </member>
        <member name="T:Spring.Data.NHibernate.IHibernateOperations">
            <summary>
            Interface that specifies a basic set of Hibernate operations.
            </summary>
            <remarks>
            Implemented by HibernateTemplate. Not often used, but a useful option
            to enhance testability, as it can easily be mocked or stubbed.
            <p>Provides HibernateTemplate's data access methods that mirror
            various Session methods. See the NHibernate ISession documentation
            for details on those methods.
            </p>
            </remarks>
            <threadsafety statis="true" instance="true"/> 
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Data.NHibernate.ICommonHibernateOperations">
            <summary>
            Interface that specifies a set of Hibernate operations that
            are common across versions of Hibernate.
            </summary>
            <remarks>
            Base interface for generic and non generic IHibernateOperations interfaces
            Not often used, but a useful option
            to enhance testability, as it can easily be mocked or stubbed.
            <p>Provides HibernateTemplate's data access methods that mirror
            various Session methods. See the NHibernate ISession documentation
            for details on those methods.
            </p>
            </remarks> 
            <author>Mark Pollack (.NET)</author>  
            <threadsafety statis="true" instance="true"/> 
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Clear">
            <summary>
            Remove all objects from the Session cache, and cancel all pending saves,
            updates and deletes.
            </summary>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Delete(System.Object)">
            <summary>
            Delete the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to delete.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Delete(System.Object,NHibernate.LockMode)">
            <summary>
            Delete the given persistent instance.
            </summary>
            <remarks>
            Obtains the specified lock mode if the instance exists, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </remarks>
            <param name="entity">Tthe persistent instance to delete.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Delete(System.String)">
            <summary>
            Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Delete(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
             Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <param name="value">The value of the parameter.</param>
            <param name="type">The Hibernate type of the parameter (or <code>null</code>).</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Delete(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <param name="values">The values of the parameters.</param>
            <param name="types"> Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Flush">
            <summary>
            Flush all pending saves, updates and deletes to the database.
            </summary>
            <remarks>
            Only invoke this for selective eager flushing, for example when ADO.NET code
            needs to see certain changes within the same transaction. Else, it's preferable
            to rely on auto-flushing at transaction completion.
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Load(System.Object,System.Object)">
            <summary>
            Load the persistent instance with the given identifier
            into the given object, throwing an exception if not found.
            </summary>
            <param name="entity">Entity the object (of the target class) to load into.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If object not found.</exception>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Refresh(System.Object)">
            <summary>
            Re-read the state of the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to re-read.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Refresh(System.Object,NHibernate.LockMode)">
            <summary>
            Re-read the state of the given persistent instance.
            Obtains the specified lock mode for the instance.
            </summary>
            <param name="entity">The persistent instance to re-read.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Contains(System.Object)">
            <summary>
            Determines whether the given object is in the Session cache.
            </summary>
            <param name="entity">the persistence instance to check.</param>
            <returns>
            	<c>true</c> if session cache contains the specified entity; otherwise, <c>false</c>.
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Evict(System.Object)">
            <summary>
            Remove the given object from the Session cache.
            </summary>
            <param name="entity">The persistent instance to evict.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Lock(System.Object,NHibernate.LockMode)">
            <summary>
            Obtain the specified lock level upon the given object, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </summary>
            <param name="entity">The he persistent instance to lock.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.ObjectOptimisticLockingFailureException">If not found</exception>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Save(System.Object)">
            <summary>
            Persist the given transient instance.
            </summary>
            <param name="entity">The transient instance to persist.</param>
            <returns>The generated identifier.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Save(System.Object,System.Object)">
            <summary>
            Persist the given transient instance with the given identifier.
            </summary>
            <param name="entity">The transient instance to persist.</param>
            <param name="id">The identifier to assign.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Update(System.Object)">
            <summary>
            Update the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to update.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Update(System.Object,NHibernate.LockMode)">
            <summary>
            Update the given persistent instance.
            Obtains the specified lock mode if the instance exists, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </summary>
            <param name="entity">The persistent instance to update.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.SaveOrUpdate(System.Object)">
            <summary>
            Save or update the given persistent instance,
            according to its id (matching the configured "unsaved-value"?).
            </summary>
            <param name="entity">Tthe persistent instance to save or update
            (to be associated with the Hibernate Session).</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.SaveOrUpdateCopy(System.Object)">
            <summary>
            Save or update the contents of given persistent object,
            according to its id (matching the configured "unsaved-value"?).
            Will copy the contained fields to an already loaded instance
            with the same id, if appropriate.
            </summary>
            <param name="entity">The persistent object to save or update.
            (<i>not</i> necessarily to be associated with the Hibernate Session)
            </param>
            <returns>The actually associated persistent object.
            (either an already loaded instance with the same id, or the given object)</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.ICommonHibernateOperations.Merge(System.Object)">
            <summary>
            Copy the state of the given object onto the persistent object with the same identifier. 
            If there is no persistent instance currently associated with the session, it will be loaded.
            Return the persistent instance. If the given instance is unsaved, 
            save a copy of and return it as a newly persistent instance.
            The given instance does not become associated with the session. 
            This operation cascades to associated instances if the association is mapped with cascade="merge".
            The semantics of this method are defined by JSR-220. 
            </summary>
            <param name="entity">The persistent object to merge.
            (<i>not</i> necessarily to be associated with the Hibernate Session)
            </param>
            <returns>An updated persistent instance</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.DeleteAll(System.Collections.ICollection)">
            <summary>
            Delete all given persistent instances.
            </summary>
            <param name="entities">The persistent instances to delete.</param>
            <remarks>
            This can be combined with any of the find methods to delete by query
            in two lines of code, similar to Session's delete by query methods.
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Execute(Spring.Data.NHibernate.HibernateDelegate)">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning a result object, i.e. a domain
            object or a collection of domain objects.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <param name="del">The delegate callback object that specifies the Hibernate action.</param>
            <returns>a result object returned by the action, or <code>null</code>
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Execute(Spring.Data.NHibernate.IHibernateCallback)">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning a result object, i.e. a domain
            object or a collection of domain objects.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <param name="action">The callback object that specifies the Hibernate action.</param>
            <returns>a result object returned by the action, or <code>null</code>
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.ExecuteFind(Spring.Data.NHibernate.IHibernateCallback)">
            <summary>
            Execute the specified action assuming that the result object is a List.
            </summary>
            <remarks>
            This is a convenience method for executing Hibernate find calls or
            queries within an action.
            </remarks>
            <param name="action">The calback object that specifies the Hibernate action.</param>
            <returns>A IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Find(System.String)">
            <summary>
            Execute a query for persistent instances.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Find(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a "?" parameter in the query string.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">the value of the parameter</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Find(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding one value
            to a "?" parameter of the given type in the query string.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">The value of the parameter.</param>
            <param name="type">Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Find(System.String,System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="values">the values of the parameters</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Find(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a number of
            values to "?" parameters of the given types in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentException">If values and types are not null and their lengths are not equal</exception>          
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedParam(System.String,System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a named parameter in the query string.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedParam(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a named parameter in the query string.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedParam(System.String,System.String[],System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to named parameters in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedParam(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to named parameters in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQuery(System.String)">
            <summary>
            Execute a named query for persistent instances.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQuery(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
             A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQuery(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQuery(System.String,System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQuery(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If values and types are not null and their lengths differ.</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQueryAndNamedParam(System.String,System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQueryAndNamedParam(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">The Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQueryAndNamedParam(System.String,System.String[],System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQueryAndNamedParam(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByNamedQueryAndValueObject(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding the properties
            of the given object to named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="valueObject">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.FindByValueObject(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding the properties
            of the given object to <i>named</i> parameters in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>       
            <param name="valueObject">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Get(System.Type,System.Object)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or <code>null</code> if not found.
            </summary>
            <param name="entityType">a persistent type.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <returns>the persistent instance, or null if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Get(System.Type,System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or <code>null</code> if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <param name="entityType">A persistent class.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <param name="lockMode">The lock mode.</param>
            the persistent instance, or <code>null</code> if not found
            <returns>the persistent instance, or null if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Load(System.Type,System.Object)">
            <summary>
            Return the persistent instance of the given entity class
             with the given identifier, throwing an exception if not found.
            </summary>
            <param name="entityType">Type of the entity.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception> 
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.Load(System.Type,System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity class
            with the given identifier, throwing an exception if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <param name="entityType">Type of the entity.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <param name="lockMode">The lock mode.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception> 
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.LoadAll(System.Type)">
            <summary>
            Return all persistent instances of the given entity class.
            Note: Use queries or criteria for retrieving a specific subset.
            </summary>
            <param name="entityType">Type of the entity.</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception> 
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateOperations.SaveOrUpdateAll(System.Collections.ICollection)">
            <summary>
            Save or update all given persistent instances,
            according to its id (matching the configured "unsaved-value"?).
            </summary>
            <param name="entities">Tthe persistent instances to save or update
            (to be associated with the Hibernate Session)he entities.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="F:Spring.Data.NHibernate.HibernateTemplate.log">
            <summary>
            The <see cref="T:Common.Logging.ILog"/> instance for this class. 
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateTemplate"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.#ctor(NHibernate.ISessionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateTemplate"/> class.
            </summary>
            <remarks>The default for creating a new non-transactional
            session when no transactional Session can be found for the current thread
            is set to true.</remarks>
            <param name="sessionFactory">The session factory to create sessions.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.#ctor(NHibernate.ISessionFactory,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateTemplate"/> class.
            </summary>
            <param name="sessionFactory">The session factory to create sessions.</param>        
            <param name="allowCreate">if set to <c>true</c> allow creation
            of a new non-transactional when no transactional Session can be found 
            for the current thread.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.ClearAction(NHibernate.ISession)">
            <summary>
            Delegate function that clears the session.
            </summary>
            <param name="session">The hibernate session.</param>
            <returns>null</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Flush">
            <summary>
            Flush all pending saves, updates and deletes to the database.
            </summary>
            <remarks>
            Only invoke this for selective eager flushing, for example when ADO.NET code
            needs to see certain changes within the same transaction. Else, it's preferable
            to rely on auto-flushing at transaction completion.
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Get(System.Type,System.Object)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or <code>null</code> if not found.
            </summary>
            <param name="entityType">The type.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <returns>The persistent instance, or <code>null</code> if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Get(System.Type,System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or <code>null</code> if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <param name="type">The type.</param>
            <param name="id">The lock mode to obtain.</param>
            <param name="lockMode">The lock mode.</param>
            the persistent instance, or <code>null</code> if not found
            <returns>the persistent instance, or null if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Load(System.Type,System.Object)">
            <summary>
            Return the persistent instance of the given entity class
            with the given identifier, throwing an exception if not found.
            </summary>
            <param name="entityType">Type of the entity.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception> 
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Load(System.Type,System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity class
             with the given identifier, throwing an exception if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <param name="entityType">Type of the entity.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <param name="lockMode">The lock mode.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception> 
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Load(System.Object,System.Object)">
            <summary>
            Load the persistent instance with the given identifier
            into the given object, throwing an exception if not found.
            </summary>
            <param name="entity">Entity the object (of the target class) to load into.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If object not found.</exception>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.LoadAll(System.Type)">
            <summary>
            Return all persistent instances of the given entity class.
            Note: Use queries or criteria for retrieving a specific subset.
            </summary>
            <param name="entityType">Type of the entity.</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception> 
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Refresh(System.Object)">
            <summary>
            Re-read the state of the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to re-read.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Refresh(System.Object,NHibernate.LockMode)">
            <summary>
            Re-read the state of the given persistent instance.
            Obtains the specified lock mode for the instance.
            </summary>
            <param name="entity">The persistent instance to re-read.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Lock(System.Object,NHibernate.LockMode)">
            <summary>
            Obtain the specified lock level upon the given object, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </summary>
            <param name="entity">The he persistent instance to lock.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.ObjectOptimisticLockingFailureException">If not found</exception>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Save(System.Object)">
            <summary>
            Persist the given transient instance.
            </summary>
            <param name="entity">The transient instance to persist.</param>
            <returns>The generated identifier.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Save(System.Object,System.Object)">
            <summary>
            Persist the given transient instance with the given identifier.
            </summary>
            <param name="entity">The transient instance to persist.</param>
            <param name="id">The identifier to assign.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Update(System.Object)">
            <summary>
            Update the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to update.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Update(System.Object,NHibernate.LockMode)">
            <summary>
            Update the given persistent instance.
            Obtains the specified lock mode if the instance exists, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </summary>
            <param name="entity">The persistent instance to update.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.SaveOrUpdate(System.Object)">
            <summary>
            Save or update the given persistent instance,
            according to its id (matching the configured "unsaved-value"?).
            </summary>
            <param name="entity">Tthe persistent instance to save or update
            (to be associated with the Hibernate Session).</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.SaveOrUpdateAll(System.Collections.ICollection)">
            <summary>
            Save or update all given persistent instances,
            according to its id (matching the configured "unsaved-value"?).
            </summary>
            <param name="entities">Tthe persistent instances to save or update
            (to be associated with the Hibernate Session)he entities.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.SaveOrUpdateCopy(System.Object)">
            <summary>
            Save or update the contents of given persistent object,
            according to its id (matching the configured "unsaved-value"?).
            Will copy the contained fields to an already loaded instance
            with the same id, if appropriate.
            </summary>
            <param name="entity">The persistent object to save or update.
            (<i>not</i> necessarily to be associated with the Hibernate Session)
            </param>
            <returns>The actually associated persistent object.
            (either an already loaded instance with the same id, or the given object)</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Merge(System.Object)">
            <summary>
            Copy the state of the given object onto the persistent object with the same identifier. 
            If there is no persistent instance currently associated with the session, it will be loaded.
            Return the persistent instance. If the given instance is unsaved, 
            save a copy of and return it as a newly persistent instance.
            The given instance does not become associated with the session. 
            This operation cascades to associated instances if the association is mapped with cascade="merge".
            The semantics of this method are defined by JSR-220. 
            </summary>
            <param name="entity">The persistent object to merge.
            (<i>not</i> necessarily to be associated with the Hibernate Session)
            </param>
            <returns>An updated persistent instance</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Clear">
            <summary>
            Remove all objects from the Session cache, and cancel all pending saves,
            updates and deletes.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Contains(System.Object)">
            <summary>
            Determines whether the given object is in the Session cache.
            </summary>
            <param name="entity">the persistence instance to check.</param>
            <returns>
            	<c>true</c> if session cache contains the specified entity; otherwise, <c>false</c>.
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Evict(System.Object)">
            <summary>
            Remove the given object from the Session cache.
            </summary>
            <param name="entity">The persistent instance to evict.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Delete(System.Object)">
            <summary>
            Delete the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to delete.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Delete(System.Object,NHibernate.LockMode)">
            <summary>
            Delete the given persistent instance.
            </summary>
            <param name="entity">Tthe persistent instance to delete.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <remarks>
            Obtains the specified lock mode if the instance exists, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Delete(System.String)">
            <summary>
            Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Delete(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
             Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <param name="value">The value of the parameter.</param>
            <param name="type">The Hibernate type of the parameter (or <code>null</code>).</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Delete(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <param name="values">The values of the parameters.</param>
            <param name="types"> Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If length for argument values and types are not equal.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.DeleteAll(System.Collections.ICollection)">
            <summary>
            Delete all given persistent instances.
            </summary>
            <param name="entities">The persistent instances to delete.</param>
            <remarks>
            This can be combined with any of the find methods to delete by query
            in two lines of code, similar to Session's delete by query methods.
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Execute(Spring.Data.NHibernate.HibernateDelegate)">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning a result object, i.e. a domain
            object or a collection of domain objects.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <param name="del">The delegate callback object that specifies the Hibernate action.</param>
            <returns>a result object returned by the action, or <code>null</code>
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Execute(Spring.Data.NHibernate.HibernateDelegate,System.Boolean)">
            <summary>
            Execute the action specified by the delegate within a Session.
            </summary>
            <param name="del">The HibernateDelegate that specifies the action
            to perform.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>a result object returned by the action, or <code>null</code>
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Execute(Spring.Data.NHibernate.IHibernateCallback)">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <param name="action">The callback object that specifies the Hibernate action.</param>
            <returns>
            a result object returned by the action, or <code>null</code>
            </returns>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning a result object, i.e. a domain
            object or a collection of domain objects.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.ExecuteFind(Spring.Data.NHibernate.IHibernateCallback)">
            <summary>
            Execute the specified action assuming that the result object is a List.
            </summary>
            <remarks>
            This is a convenience method for executing Hibernate find calls or
            queries within an action.
            </remarks>
            <param name="action">The calback object that specifies the Hibernate action.</param>
            <returns>A IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Execute(Spring.Data.NHibernate.IHibernateCallback,System.Boolean)">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <param name="action">callback object that specifies the Hibernate action.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>
            a result object returned by the action, or <code>null</code>
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Find(System.String)">
            <summary>
            Execute a query for persistent instances.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <returns>
            a List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Find(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a "?" parameter in the query string.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">the value of the parameter</param>
            <returns>
            a List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Find(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding one value
            to a "?" parameter of the given type in the query string.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">The value of the parameter.</param>
            <param name="type">Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>
            a List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Find(System.String,System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="values">the values of the parameters</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.Find(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a number of
            values to "?" parameters of the given types in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>
            a List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentException">If values and types are not null and their lengths are not equal</exception>          
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedParam(System.String,System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a named parameter in the query string.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>a List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedParam(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a named parameter in the query string.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedParam(System.String,System.String[],System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to named parameters in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedParam(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to named parameters in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQuery(System.String)">
            <summary>
            Execute a named query for persistent instances.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQuery(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
             A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQuery(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQuery(System.String,System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQuery(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If values and types are not null and their lengths differ.</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQueryAndNamedParam(System.String,System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQueryAndNamedParam(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">The Hibernate type of the parameter (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQueryAndNamedParam(System.String,System.String[],System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQueryAndNamedParam(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <param name="types">Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>                
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByNamedQueryAndValueObject(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding the properties
            of the given object to  named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="valueObject">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.FindByValueObject(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding the properties
            of the given object to <i>named</i> parameters in the query string.
            </summary>
            <param name="queryString">A query expressed in Hibernate's query language</param>       
            <param name="valueObject">The values of the parameters</param>
            <returns>A List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.CreateSessionProxy(NHibernate.ISession)">
            <summary>
            Create a close-suppressing proxy for the given Hibernate Session.
            The proxy also prepares returned Query and Criteria objects.
            </summary>
            <param name="session">The session.</param>
            <returns>The session proxy.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.CheckWriteOperationAllowed(NHibernate.ISession)">
            <summary>
            Check whether write operations are allowed on the given Session.
            </summary>
            <remarks>
            Default implementation throws an InvalidDataAccessApiUsageException
            in case of FlushMode.Never. Can be overridden in subclasses.
            </remarks>
            <param name="session">The current Hibernate session.</param>
            <exception cref="T:Spring.Dao.InvalidDataAccessApiUsageException">If write operation is attempted in read-only mode
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTemplate.AreEqualFlushMode(Spring.Data.NHibernate.TemplateFlushMode,NHibernate.FlushMode)">
            <summary>
            Compares if the flush mode enumerations, Spring's
            TemplateFlushMode and NHibernates FlushMode have equal
            settings.
            </summary>
            <param name="tfm">The template flush mode.</param>
            <param name="fm">The NHibernate flush mode.</param>
            <returns>
            Returns true if both are Never, Auto, or Commit, false
            otherwise.
            </returns>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.AllowCreate">
            <summary>
            Gets or sets if a new Session should be created when no transactional Session
            can be found for the current thread.
            </summary>
            <value>
            	<c>true</c> if allowed to create non-transaction session;
            otherwise, <c>false</c>.
            </value>
            <remarks>
            	<p>HibernateTemplate is aware of a corresponding Session bound to the
            current thread, for example when using HibernateTransactionManager.
            If allowCreate is true, a new non-transactional Session will be created
            if none found, which needs to be closed at the end of the operation.
            If false, an InvalidOperationException will get thrown in this case.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.AlwaysUseNewSession">
            <summary>
            Gets or sets a value indicating whether to always
            use a new Hibernate Session for this template.
            </summary>
            <value><c>true</c> if always use new session; otherwise, <c>false</c>.</value>
            <remarks>
            	<p>
            Default is "false"; if activated, all operations on this template will
            work on a new NHibernate ISession even in case of a pre-bound ISession
            (for example, within a transaction).
            </p>
            	<p>Within a transaction, a new NHibernate ISession used by this template
            will participate in the transaction through using the same ADO.NET
            Connection. In such a scenario, multiple Sessions will participate
            in the same database transaction.
            </p>
            	<p>Turn this on for operations that are supposed to always execute
            independently, without side effects caused by a shared NHibernate ISession.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.TemplateFlushMode">
            <summary>
            Gets or sets the template flush mode.
            </summary>
            <remarks>
            Default is Auto. Will get applied to any <b>new</b> ISession
            created by the template.
            </remarks>
            <value>The template flush mode.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.EntityInterceptor">
            <summary>
            Gets or sets the entity interceptor that allows to inspect and change
            property values before writing to and reading from the database.
            </summary>
            <remarks>
            Will get applied to any <b>new</b> ISession created by this object.
            <p>Such an interceptor can either be set at the ISessionFactory level,
            i.e. on LocalSessionFactoryObject, or at the ISession level, i.e. on
            HibernateTemplate, HibernateInterceptor, and HibernateTransactionManager.
            It's preferable to set it on LocalSessionFactoryObject or HibernateTransactionManager
            to avoid repeated configuration and guarantee consistent behavior in transactions.
            </p>
            </remarks>
            <value>The interceptor.</value>
            <exception cref="T:System.InvalidOperationException">If object factory is not set and need to retrieve entity interceptor by name.</exception>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.QueryCacheRegion">
            <summary>
            Gets or sets the name of the cache region for queries executed by this template.
            </summary>
            <remarks>
            If this is specified, it will be applied to all IQuery and ICriteria objects
            created by this template (including all queries through find methods).
            <p>The cache region will not take effect unless queries created by this
            template are configured to be cached via the CacheQueries property.
            </p>
            </remarks>
            <value>The query cache region.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.CacheQueries">
            <summary>
            Gets or sets a value indicating whether to 
            cache all queries executed by this template.
            </summary>
            <remarks>
            If this is true, all IQuery and ICriteria objects created by
            this template will be marked as cacheable (including all
            queries through find methods).
            <p>To specify the query region to be used for queries cached
            by this template, set the QueryCacheRegion property.
            </p>
            </remarks>
            <value><c>true</c> if cache queries; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.MaxResults">
            <summary>
            Gets or sets the maximum number of rows for this HibernateTemplate.
            </summary>
            <value>The max results.</value>
            <remarks>
            This is important
            for processing subsets of large result sets, avoiding to read and hold
            the entire result set in the database or in the ADO.NET driver if we're
            never interested in the entire result in the first place (for example,
            when performing searches that might return a large number of matches).
            <p>Default is 0, indicating to use the driver's default.</p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.ExposeNativeSession">
            <summary>
            Set whether to expose the native Hibernate Session to IHibernateCallback
            code. Default is "false": a Session proxy will be returned,
            suppressing <code>close</code> calls and automatically applying
            query cache settings and transaction timeouts.
            </summary>
            <value><c>true</c> if expose native session; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.CheckWriteOperations">
            <summary>
            Gets or sets  whether to check that the Hibernate Session is not in read-only mode
            in case of write operations (save/update/delete).
            </summary>
            <value>
            	<c>true</c> if check that the Hibernate Session is not in read-only mode
            in case of write operations; otherwise, <c>false</c>.
            </value>
            <remarks>
            Default is "true", for fail-fast behavior when attempting write operations
            within a read-only transaction. Turn this off to allow save/update/delete
            on a Session with flush mode NEVER.
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.EntityInterceptorObjectName">
            <summary>
            Set the object name of a Hibernate entity interceptor that allows to inspect
            and change property values before writing to and reading from the database.
            </summary>
            <remarks>
            Will get applied to any new Session created by this transaction manager.
            <p>Requires the object factory to be known, to be able to resolve the object
            name to an interceptor instance on session creation. Typically used for
            prototype interceptors, i.e. a new interceptor instance per session.
            </p>
            <p>Can also be used for shared interceptor instances, but it is recommended
            to set the interceptor reference directly in such a scenario.
            </p>
            </remarks>
            <value>The name of the entity interceptor in the object factory/application context.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.ObjectFactory">
            <summary>
            Set the object factory instance.
            </summary>
            <value>The object factory instance</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.SessionFactory">
            <summary>
            Gets or sets the session factory that should be used to create
            NHibernate ISessions.
            </summary>
            <value>The session factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.FetchSize">
            <summary>
            Gets or sets the fetch size for this HibernateTemplate.
            </summary>
            <value>The size of the fetch.</value>
            <remarks>This is important for processing
            large result sets: Setting this higher than the default value will increase
            processing speed at the cost of memory consumption; setting this lower can
            avoid transferring row data that will never be read by the application.
            <p>Default is 0, indicating to use the driver's default.</p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.ProxyFactory">
            <summary>
            Gets or sets the proxy factory.
            </summary>
            <remarks>This may be useful to set if you create many instances of 
            HibernateTemplate and/or HibernateDaoSupport.  This allows the same
            ProxyFactory implementation to be used thereby limiting the
            number of dynamic proxy types created in the temporary assembly, which
            are never garbage collected due to .NET runtime semantics.
            </remarks>
            <value>The proxy factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTemplate.AdoExceptionTranslator">
            <summary>
            Set the ADO.NET exception translator for this instance.
            Applied to System.Data.Common.DbException (or provider specific exception type
            in .NET 1.1) thrown by callback code, be it direct
            DbException or wrapped Hibernate ADOExceptions.
            <p>The default exception translator is either a ErrorCodeExceptionTranslator
            if a DbProvider is available, or a FalbackExceptionTranslator otherwise
            </p>
            </summary>
            <value>The ADO exception translator.</value>
        </member>
        <member name="T:Spring.Data.NHibernate.IHibernateCallback">
            <summary>
            Callback interface for NHibernate code.
            </summary>
            <remarks>To be used with HibernateTemplate execute
            method. The typical implementation will call 
            Session.load/find/save/update to perform
            some operations on persistent objects.
            </remarks>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.IHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
            <returns>A result object, or null if none.</returns>   
        </member>
        <member name="M:Spring.Data.NHibernate.DeletebyQueryHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.DeleteAllHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.EvictHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.FindHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.FindByNamedParamHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.FindByNamedQueryHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.FindByNamedQueryAndNamedParamHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.FindByNamedQueryAndValueObjectHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.GetByTypeHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.LoadByTypeHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.LoadByEntityHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.LoadAllByTypeHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.LockHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.RefreshHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SaveObjectHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SaveObjectWithIdHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.UpdateObjectHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SaveOrUpdateObjectHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SaveOrUpdateAllHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SaveOrUpdateCopyHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.MergeHibernateCallback.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateTransactionManager">
            <summary>
            PlatformTransactionManager implementation for a single Hibernate SessionFactory.
            Binds a Hibernate Session from the specified factory to the thread, potentially
            allowing for one thread Session per factory
            </summary>
            <remarks>
            SessionFactoryUtils and HibernateTemplate are aware of thread-bound Sessions and participate in such
            transactions automatically. Using either of those is required for Hibernate
            access code that needs to support this transaction handling mechanism.
            <para>
            Supports custom isolation levels at the start of the transaction
            , and timeouts that get applied as appropriate
            Hibernate query timeouts. To support the latter, application code must either use
            <code>HibernateTemplate</code> (which by default applies the timeouts) or call
            <code>SessionFactoryUtils.applyTransactionTimeout</code> for each created
            Hibernate Query object.
            </para>
            <para>Note that you can specify a Spring IDbProvider instance which if shared with
            a corresponding instance of AdoTemplate will allow for mixing ADO.NET/NHibernate
            operations within a single transaction.</para>
            </remarks>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.HibernateTransactionManager.objectFactory">
            <summary>
            Just needed for entityInterceptorBeanName. 
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateTransactionManager"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.#ctor(NHibernate.ISessionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateTransactionManager"/> class.
            </summary>
            <param name="sessionFactory">The session factory.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoGetTransaction">
            <summary>
            Return the current transaction object.
            </summary>
            <returns>The current transaction object.</returns>
            <exception cref="T:Spring.Transaction.CannotCreateTransactionException">
            If transaction support is not available.
            </exception>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of lookup or system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.IsExistingTransaction(System.Object)">
            <summary>
            Check if the given transaction object indicates an existing,
            i.e. already begun, transaction.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <returns>True if there is an existing transaction.</returns>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoBegin(System.Object,Spring.Transaction.ITransactionDefinition)">
            <summary>
            Begin a new transaction with the given transaction definition.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <param name="definition">
            <see cref="T:Spring.Transaction.ITransactionDefinition"/> instance, describing
            propagation behavior, isolation level, timeout etc.
            </param>
            <remarks>
            Does not have to care about applying the propagation behavior,
            as this has already been handled by this abstract manager.
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of creation or system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoSuspend(System.Object)">
            <summary>
            Suspend the resources of the current transaction.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <returns>
            An object that holds suspended resources (will be kept unexamined for passing it into
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoResume(System.Object,System.Object)"/>.)
            </returns>
            <remarks>
            Transaction synchronization will already have been suspended.
            </remarks>
            <exception cref="T:Spring.Transaction.IllegalTransactionStateException">
            If suspending is not supported by the transaction manager implementation.
            </exception>
            <exception cref="T:Spring.Transaction.TransactionException">
            in case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoResume(System.Object,System.Object)">
            <summary>
            Resume the resources of the current transaction.
            </summary>
            <param name="transaction">
            Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.
            </param>
            <param name="suspendedResources">
            The object that holds suspended resources as returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoSuspend(System.Object)"/>.
            </param>
            <remarks>
            Transaction synchronization will be resumed afterwards.
            </remarks>
            <exception cref="T:Spring.Transaction.IllegalTransactionStateException">
            If suspending is not supported by the transaction manager implementation.
            </exception>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoCommit(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Perform an actual commit on the given transaction.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <remarks>
            <p>
            An implementation does not need to check the rollback-only flag.
            </p>
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoRollback(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Perform an actual rollback on the given transaction.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <remarks>
            An implementation does not need to check the new transaction flag.
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoSetRollbackOnly(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Set the given transaction rollback-only. Only called on rollback
            if the current transaction takes part in an existing one.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.GetIDbTransaction(NHibernate.ITransaction)">
            <summary>
            Gets the ADO.NET IDbTransaction object from the NHibernate ITransaction object.
            </summary>
            <param name="hibernateTx">The hibernate transaction.</param>
            <returns>The ADO.NET transaction.  Null if could not get the transaction.  Warning
            messages will be logged in that case.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.ConvertHibernateAccessException(NHibernate.HibernateException)">
            <summary>
            Convert the given HibernateException to an appropriate exception from
            the Spring.Dao hierarchy. Can be overridden in subclasses.
            </summary>
            <param name="ex">The HibernateException that occured.</param>
            <returns>The corresponding DataAccessException instance</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.ConvertAdoAccessException(NHibernate.ADOException,Spring.Data.Support.IAdoExceptionTranslator)">
            <summary>
            Convert the given ADOException to an appropriate exception from the
            the Spring.Dao hierarchy. Can be overridden in subclasses.
            </summary>
            <param name="ex">The ADOException that occured, wrapping the underlying
            ADO.NET thrown exception.</param>
            <param name="translator">The translator to convert hibernate ADOExceptions.</param>
            <returns>
            The corresponding DataAccessException instance
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.DoCleanupAfterCompletion(System.Object)">
            <summary>
            Cleanup resources after transaction completion.
            </summary>
            <param name="transaction">Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
            <remarks>
            <note>
            This implemenation unbinds the SessionFactory and 
            DbProvider from thread local storage and closes the 
            ISession.
            </note>
            	<p>
            Called after <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoCommit(Spring.Transaction.Support.DefaultTransactionStatus)"/>
            and
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoRollback(Spring.Transaction.Support.DefaultTransactionStatus)"/>
            execution on any outcome.
            </p>
            	<p>
            Should not throw any exceptions but just issue warnings on errors.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateTransactionManager.AfterPropertiesSet">
            <summary>
            Invoked by an <see cref="T:Spring.Objects.Factory.IObjectFactory"/>
            after it has injected all of an object's dependencies.
            </summary>
            <remarks>
            <p>
            This method allows the object instance to perform the kind of
            initialization only possible when all of it's dependencies have
            been injected (set), and to throw an appropriate exception in the
            event of misconfiguration.
            </p>
            <p>
            Please do consult the class level documentation for the
            <see cref="T:Spring.Objects.Factory.IObjectFactory"/> interface for a
            description of exactly <i>when</i> this method is invoked. In
            particular, it is worth noting that the
            <see cref="T:Spring.Objects.Factory.IObjectFactoryAware"/>
            and <see cref="T:Spring.Context.IApplicationContextAware"/>
            callbacks will have been invoked <i>prior</i> to this method being
            called.
            </p>
            </remarks>
            <exception cref="T:System.ArgumentException">
            In the event of misconfiguration (such as the failure to set a
            required property) or if initialization fails.
            </exception>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.DbProvider">
            <summary>
            Gets or sets the db provider.
            </summary>
            <value>The db provider.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.EntityInterceptor">
            <summary>
            Gets or sets a Hibernate entity interceptor that allows to inspect and change
            property values before writing to and reading from the database.
            When getting, return the current Hibernate entity interceptor, or <code>null</code> if none.
            </summary>
            <value>The entity interceptor.</value>
            <remarks>
            Resolves an entity interceptor object name via the object factory,
            if necessary.
            Will get applied to any new Session created by this transaction manager.
            Such an interceptor can either be set at the SessionFactory level,
            i.e. on LocalSessionFactoryObject, or at the Session level, i.e. on
            HibernateTemplate, HibernateInterceptor, and HibernateTransactionManager.
            It's preferable to set it on LocalSessionFactoryObject or HibernateTransactionManager
            to avoid repeated configuration and guarantee consistent behavior in transactions.
            </remarks>
            <exception cref="T:System.InvalidOperationException">If object factory is null and need to get entity interceptor via object name.</exception>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.EntityInterceptorObjectName">
            <summary>
            Sets the object name of a Hibernate entity interceptor that
            allows to inspect and change property values before writing to and reading from the database.
            </summary>
            <value>The name of the entity interceptor object.</value>
            <remarks>
            Will get applied to any new Session created by this transaction manager.
            <p>Requires the object factory to be known, to be able to resolve the object
            name to an interceptor instance on session creation. Typically used for
            prototype interceptors, i.e. a new interceptor instance per session.
            </p>
            	<p>Can also be used for shared interceptor instances, but it is recommended
            to set the interceptor reference directly in such a scenario.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.AdoExceptionTranslator">
            <summary>
            Gets or sets the ADO.NET exception translator for this transaction manager.
            </summary>
            <remarks>
            Applied to ADO.NET Exceptions (wrapped by Hibernate's ADOException)
            </remarks>
            <value>The ADO exception translator.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.DefaultAdoExceptionTranslator">
            <summary>
            Gets the default IAdoException translator, lazily creating it if nece
            </summary>
            <value>The default IAdoException translator.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.SessionFactory">
            <summary>
            Gets or sets the SessionFactory that this instance should manage transactions for.
            </summary>
            <value>The session factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.ResourceFactory">
            <summary>
            Gets the resource factory that this transaction manager operates on,
            For the HibenratePlatformTransactionManager this the SessionFactory
            </summary>
            <value>The SessionFactory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.AutodetectDbProvider">
            <summary>
            Set whether to autodetect a ADO.NET connection used by the Hibernate SessionFactory,
            if set via LocalSessionFactoryObject's <code>DbProvider</code>. Default is "true".
            </summary>
            <value>
            	<c>true</c> if [autodetect data source]; otherwise, <c>false</c>.
            </value>
            <remarks>
            	<p>Can be turned off to deliberately ignore an available IDbProvider,
            to not expose Hibernate transactions as ADO.NET transactions for that IDbProvider.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.ObjectFactory">
            <summary>
            The object factory just needs to be known for resolving entity interceptor
            It does not need to be set for any other mode of operation.
            </summary>
            <value>
            Owning <see cref="T:Spring.Objects.Factory.IObjectFactory"/>
            (may not be <see langword="null"/>). The object can immediately
            call methods on the factory.
            </value>
        </member>
        <member name="P:Spring.Data.NHibernate.HibernateTransactionManager.HibernateTransactionObject.RollbackOnly">
            <summary>
            Return whether the transaction is internally marked as rollback-only.
            </summary>
            <value></value>
            <returns>True of the transaction is marked as rollback-only.</returns>
        </member>
        <member name="T:Spring.Data.NHibernate.TemplateFlushMode">
            <summary>
            Enumeration for the various Hibernate flush modes. 
            </summary>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.TemplateFlushMode.Never">
            <summary>Never flush is a good strategy for read-only units of work.
            </summary>
            <remarks>
            Hibernate will not track and look for changes in this case,
            avoiding any overhead of modification detection.
            <p>In case of an existing ISession, TemplateFlushMode.Never will turn 
            the hibenrate flush mode
            to FlushMode.Never for the scope of the current operation, resetting the previous
            flush mode afterwards.
            </p>
            </remarks>
        </member>
        <member name="F:Spring.Data.NHibernate.TemplateFlushMode.Auto">
            <summary>Automatic flushing is the default mode for a Hibernate Session.
            </summary>
            <remarks>
            A session will get flushed on transaction commit, and on certain find
            operations that might involve already modified instances, but not
            after each unit of work like with eager flushing.
            <p>In case of an existing Session, TemplateFlushMode.Auto
            will participate in the existing flush mode, not modifying 
            it for the current operation.
            This in particular means that this setting will not modify an existing
            hibernate flush mode FlushMode.Never, in contrast to TemplateFlushMode.Eager.
            </p>
            </remarks>
        </member>
        <member name="F:Spring.Data.NHibernate.TemplateFlushMode.Eager">
            <summary>
            Eager flushing leads to immediate synchronization with the database,
            even if in a transaction. 
            </summary>
            <remarks>
            This causes inconsistencies to show up and throw
            a respective exception immediately, and ADO access code that participates
            in the same transaction will see the changes as the database is already
            aware of them then. But the drawbacks are:
            <ul>
            <li>additional communication roundtrips with the database, instead of a
            single batch at transaction commit;</li>
            <li>the fact that an actual database rollback is needed if the Hibernate
            transaction rolls back (due to already submitted SQL statements).</li>
            </ul>
            <p>In case of an existing Session, TemplateFlushMode.Eager
            will turn the NHibernate flush mode 
            to FlushMode.Auto for the scope of the current operation and issue a flush at the
            end, resetting the previous flush mode afterwards.
            </p>
            </remarks>
        </member>
        <member name="F:Spring.Data.NHibernate.TemplateFlushMode.Commit">
            <summary>
            Flushing at commit only is intended for units of work where no
            intermediate flushing is desired, not even for find operations
            that might involve already modified instances.
            </summary>
            <remarks>
            <p>In case of an existing Session, TemplateFlushMode.Commit
            will turn the NHibernate flush mode
            to FlushMode.Commit for the scope of the current operation, resetting the previous
            flush mode afterwards. The only exception is an existing flush mode
            FlushMode.Never, which will not be modified through this setting.
            </p>
            </remarks>
        </member>
        <member name="T:Spring.Data.NHibernate.Generic.FindHibernateDelegate`1">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning an IList of result objects created within the callback. 
            Note that there's special support for single step actions: 
            see HibernateTemplate.find etc.
            </p>
            </remarks>
            <typeparam name="T">The type of result object</typeparam>
            <author>Sree Nivask (.NET)</author>
        </member>
        <member name="T:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport">
            <summary>
             Convenient super class for Hibernate data access objects.
            </summary>
            <remarks>
            <para>Requires a SessionFactory to be set, providing a HibernateTemplate
             based on it to subclasses. Can alternatively be initialized directly with
            a HibernateTemplate, to reuse the latter's settings such as the SessionFactory,
             exception translator, flush mode, etc
            </para>
            This base call is mainly intended for HibernateTemplate usage.
            <para>
            This class will create its own HibernateTemplate if only a SessionFactory
            is passed in. The "allowCreate" flag on that HibernateTemplate will be "true"
            by default. A custom HibernateTemplate instance can be used through overriding
            <code>CreateHibernateTemplate</code>.
            </para>
            </remarks>
            <author>Sree Nivask (.NET)</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.CreateHibernateTemplate(NHibernate.ISessionFactory)">
            <summary>
            Create a HibernateTemplate for the given ISessionFactory.
            </summary>
            <remarks>
            Only invoked if populating the DAO with a ISessionFactory reference!
            <p>Can be overridden in subclasses to provide a HibernateTemplate instance
            with different configuration, or a custom HibernateTemplate subclass.
            </p>
            </remarks>
            <returns>The new HibernateTemplate instance</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.CheckDaoConfig">
            <summary>
            Check if the hibernate template property has been set.
            </summary>
            <exception cref="T:System.ArgumentException">If HibernateTemplate property is null.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.DoGetSession(System.Boolean)">
            <summary>
            Get a Hibernate Session, either from the current transaction or
            a new one. The latter is only allowed if "allowCreate" is true.
            </summary>
            <remarks>Note that this is not meant to be invoked from HibernateTemplate code
            but rather just in plain Hibernate code. Either rely on a thread-bound
            Session (via HibernateInterceptor), or use it in combination with
            ReleaseSession.
            <para>
            In general, it is recommended to use HibernateTemplate, either with
            the provided convenience operations or with a custom HibernateCallback
            that provides you with a Session to work on. HibernateTemplate will care
            for all resource management and for proper exception conversion.
            </para>
            </remarks>
            <param name="allowCreate"> if a non-transactional Session should be created when no
            transactional Session can be found for the current thread
            </param>
            <returns>Hibernate session.</returns>
            <exception cref="T:Spring.Dao.DataAccessResourceFailureException">
            If the Session couldn't be created
            </exception>
            <exception cref="T:System.InvalidOperationException">
            if no thread-bound Session found and allowCreate false
            </exception>
            <seealso cref="M:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.ReleaseSession(NHibernate.ISession)"/>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.ConvertHibernateAccessException(NHibernate.HibernateException)">
            <summary>
            Convert the given HibernateException to an appropriate exception from the
            <code>org.springframework.dao</code> hierarchy. Will automatically detect
            wrapped ADO.NET Exceptions and convert them accordingly.
            </summary>
            <param name="ex">HibernateException that occured.</param>
            <returns>
            The corresponding DataAccessException instance
            </returns>
            <remarks>
            The default implementation delegates to SessionFactoryUtils
            and convertAdoAccessException. Can be overridden in subclasses.
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.ReleaseSession(NHibernate.ISession)">
            <summary>
            Close the given Hibernate Session, created via this DAO's SessionFactory,
            if it isn't bound to the thread.
            </summary>
            <remarks>
            Typically used in plain Hibernate code, in combination with the 
            Session property and ConvertHibernateAccessException.
            </remarks>      
            <param name="session">The session to close.</param>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.HibernateTemplate">
            <summary>
            Gets or sets the hibernate template.
            </summary>
            <remarks>Set the HibernateTemplate for this DAO explicitly,
            as an alternative to specifying a SessionFactory.
            </remarks>
            <value>The hibernate template.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.SessionFactory">
            <summary>
            Gets or sets the session factory to be used by this DAO.
            Will automatically create a HibernateTemplate for the given SessionFactory.
            </summary>
            <value>The session factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport.Session">
            <summary>
            Get a Hibernate Session, either from the current transaction or a new one.
            The latter is only allowed if the "allowCreate" setting of this object's
            HibernateTemplate is true.
            </summary>
            <remarks>
            <p><b>Note that this is not meant to be invoked from HibernateTemplate code
            but rather just in plain Hibernate code.</b> Use it in combination with
            <b>ReleaseSession</b>.
            </p>
            <p>In general, it is recommended to use HibernateTemplate, either with
            the provided convenience operations or with a custom HibernateCallback
            that provides you with a Session to work on. HibernateTemplate will care
            for all resource management and for proper exception conversion.
            </p>
            </remarks>
            <value>The Hibernate session.</value>
        </member>
        <member name="T:Spring.Data.NHibernate.Generic.HibernateDelegate`1">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning the result object created within the callback. 
            Note that there's special support for single step actions: 
            see HibernateTemplate.find etc.
            </p>
            </remarks>
            <typeparam name="T">The type of result object</typeparam>
            <author>Sree Nivask (.NET)</author>
        </member>
        <member name="T:Spring.Data.NHibernate.Generic.HibernateTemplate">
             <summary>
             Generic version of the Helper class that simplifies NHibernate data access code
             </summary>
             <remarks>
             <p>Typically used to implement data access or business logic services that
             use NHibernate within their implementation but are Hibernate-agnostic in their
             interface. The latter or code calling the latter only have to deal with
             domain objects.</p>
            
             <p>The central method is Execute() supporting Hibernate access code which
             implements the HibernateCallback interface. It provides NHibernate Session
             handling such that neither the IHibernateCallback implementation nor the calling
             code needs to explicitly care about retrieving/closing NHibernate Sessions,
             or handling Session lifecycle exceptions. For typical single step actions,
             there are various convenience methods (Find, Load, SaveOrUpdate, Delete).
             </p>
             
             <p>Can be used within a service implementation via direct instantiation
             with a ISessionFactory reference, or get prepared in an application context
             and given to services as an object reference. Note: The ISessionFactory should
             always be configured as an object in the application context, in the first case
             given to the service directly, in the second case to the prepared template.
             </p>
             
             <p>This class can be considered as a direct alternative to working with the raw
             Hibernate Session API (through SessionFactoryUtils.Session).
             </p>
             
             <p>LocalSessionFactoryObject is the preferred way of obtaining a reference
             to a specific NHibernate ISessionFactory.
             </p>
             </remarks>
             <author>Sree Nivask (.NET)</author>
             <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Data.NHibernate.Generic.IHibernateOperations">
            <summary>
            Interface that specifies a basic set of Hibernate operations.
            </summary>
            <remarks>
            Implemented by HibernateTemplate. Not often used, but a useful option
            to enhance testability, as it can easily be mocked or stubbed.
            <p>Provides HibernateTemplate's data access methods that mirror
            various Session methods. See the NHibernate ISession documentation
            for details on those methods.
            </p>
            </remarks>
            <threadsafety statis="true" instance="true"/>
            <author>Sree Nivask (.NET)</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Get``1(System.Object)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or <see langword="null"/> if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <typeparam name="T">The object type to get.</typeparam>
            <param name="id">The id of the object to get.</param>
            <returns>the persistent instance, or <see langword="null"/> if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Get``1(System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or null if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <typeparam name="T">The object type to get.</typeparam>
            <param name="id">The lock mode to obtain.</param>
            <param name="lockMode">The lock mode.</param>
            <returns>the persistent instance, or null if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>     
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Load``1(System.Object)">
            <summary>
            Return the persistent instance of the given entity class
            with the given identifier, throwing an exception if not found.
            </summary>
            <typeparam name="T">The object type to load.</typeparam>
            <param name="id">An identifier of the persistent instance.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>     
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Load``1(System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity class
             with the given identifier, throwing an exception if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <typeparam name="T">The object type to load.</typeparam>
            <param name="id">An identifier of the persistent instance.</param>
            <param name="lockMode">The lock mode.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.LoadAll``1">
            <summary>
            Return all persistent instances of the given entity class.
            Note: Use queries or criteria for retrieving a specific subset.
            </summary>
            <typeparam name="T">The object type to load.</typeparam>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Find``1(System.String)">
            <summary>
            Execute a query for persistent instances.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Find``1(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a "?" parameter in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">the value of the parameter</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Find``1(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding one value
            to a "?" parameter of the given type in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">The value of the parameter.</param>
            <param name="type">Hibernate type of the parameter (or null)</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Find``1(System.String,System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="values">the values of the parameters</param>
            <returns>a generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Find``1(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a number of
            values to "?" parameters of the given types in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception> 
            <exception cref="T:System.ArgumentException">If values and types are not null and their lenths are not equal</exception>          
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedParam``1(System.String,System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a  named parameter in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>a generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedParam``1(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a  named parameter in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedParam``1(System.String,System.String[],System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to  named parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedParam``1(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to  named parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQuery``1(System.String)">
            <summary>
            Execute a named query for persistent instances.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQuery``1(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
             A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQuery``1(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQuery``1(System.String,System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQuery``1(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If values and types are not null and their lengths differ.</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQueryAndNamedParam``1(System.String,System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a  named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQueryAndNamedParam``1(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a  named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">The Hibernate type of the parameter (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQueryAndNamedParam``1(System.String,System.String[],System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQueryAndNamedParam``1(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to  named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>                
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByNamedQueryAndValueObject``1(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding the properties
            of the given object to  named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="valueObject">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.FindByValueObject``1(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding the properties
            of the given object to <i>named</i> parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>       
            <param name="valueObject">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Execute``1(Spring.Data.NHibernate.Generic.HibernateDelegate{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="del">The delegate callback object that specifies the Hibernate action.</param>
            <returns>a result object returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Execute``1(Spring.Data.NHibernate.Generic.HibernateDelegate{``0},System.Boolean)">
            <summary>
            Execute the action specified by the delegate within a Session.
            </summary>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="del">The HibernateDelegate that specifies the action
            to perform.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>a result object returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Execute``1(Spring.Data.NHibernate.Generic.IHibernateCallback{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="action">The callback object that specifies the Hibernate action.</param>
            <returns>
            a result object returned by the action, or null
            </returns>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.Execute``1(Spring.Data.NHibernate.Generic.IHibernateCallback{``0},System.Boolean)">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="action">callback object that specifies the Hibernate action.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>
            a result object returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.ExecuteFind``1(Spring.Data.NHibernate.Generic.FindHibernateDelegate{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="del">The delegate callback object that specifies the Hibernate action.</param>
            <returns>A generic IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.ExecuteFind``1(Spring.Data.NHibernate.Generic.FindHibernateDelegate{``0},System.Boolean)">
            <summary>
            Execute the action specified by the delegate within a Session.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="del">The FindHibernateDelegate that specifies the action
            to perform.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>A generic IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.ExecuteFind``1(Spring.Data.NHibernate.Generic.IFindHibernateCallback{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="action">The callback object that specifies the Hibernate action.</param>
            <returns>
            A generic IList returned by the action, or null
            </returns>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateOperations.ExecuteFind``1(Spring.Data.NHibernate.Generic.IFindHibernateCallback{``0},System.Boolean)">
            <summary>
            Execute the action specified by the given action object within a Session assuming that an IList is returned.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="action">callback object that specifies the Hibernate action.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>
            an IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Generic.HibernateTemplate"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.#ctor(NHibernate.ISessionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Generic.HibernateTemplate"/> class.
            </summary>
            <remarks>Allows creation of a new non-transactional session when no 
            transactional Session can be found for the current thread</remarks>
            <param name="sessionFactory">The session factory to create sessions.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.#ctor(NHibernate.ISessionFactory,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.Generic.HibernateTemplate"/> class.
            </summary>
            <param name="sessionFactory">The session factory to create sessions.</param>        
            <param name="allowCreate">if set to <c>true</c> allow creation
            of a new non-transactional session when no transactional Session can be found 
            for the current thread.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Clear">
            <summary>
            Remove all objects from the Session cache, and cancel all pending saves,
            updates and deletes.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Delete(System.Object)">
            <summary>
            Delete the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to delete.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Delete(System.Object,NHibernate.LockMode)">
            <summary>
            Delete the given persistent instance.
            </summary>
            <param name="entity">Tthe persistent instance to delete.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <remarks>
            Obtains the specified lock mode if the instance exists, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Delete(System.String)">
            <summary>
            Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Delete(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
             Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <param name="value">The value of the parameter.</param>
            <param name="type">The Hibernate type of the parameter (or <code>null</code>).</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Delete(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Delete all objects returned by the query.
            </summary>
            <param name="queryString">a query expressed in Hibernate's query language.</param>
            <param name="values">The values of the parameters.</param>
            <param name="types"> Hibernate types of the parameters (or <code>null</code>)</param>
            <returns>The number of entity instances deleted.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Flush">
            <summary>
            Flush all pending saves, updates and deletes to the database.
            </summary>
            <remarks>
            Only invoke this for selective eager flushing, for example when ADO.NET code
            needs to see certain changes within the same transaction. Else, it's preferable
            to rely on auto-flushing at transaction completion.
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Load(System.Object,System.Object)">
            <summary>
            Load the persistent instance with the given identifier
            into the given object, throwing an exception if not found.
            </summary>
            <param name="entity">Entity the object (of the target class) to load into.</param>
            <param name="id">An identifier of the persistent instance.</param>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If object not found.</exception>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Refresh(System.Object)">
            <summary>
            Re-read the state of the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to re-read.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Refresh(System.Object,NHibernate.LockMode)">
            <summary>
            Re-read the state of the given persistent instance.
            Obtains the specified lock mode for the instance.
            </summary>
            <param name="entity">The persistent instance to re-read.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Contains(System.Object)">
            <summary>
            Determines whether the given object is in the Session cache.
            </summary>
            <param name="entity">the persistence instance to check.</param>
            <returns>
            	<c>true</c> if session cache contains the specified entity; otherwise, <c>false</c>.
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Evict(System.Object)">
            <summary>
            Remove the given object from the Session cache.
            </summary>
            <param name="entity">The persistent instance to evict.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Lock(System.Object,NHibernate.LockMode)">
            <summary>
            Obtain the specified lock level upon the given object, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </summary>
            <param name="entity">The he persistent instance to lock.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.ObjectOptimisticLockingFailureException">If not found</exception>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Save(System.Object)">
            <summary>
            Persist the given transient instance.
            </summary>
            <param name="entity">The transient instance to persist.</param>
            <returns>The generated identifier.</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Save(System.Object,System.Object)">
            <summary>
            Persist the given transient instance with the given identifier.
            </summary>
            <param name="entity">The transient instance to persist.</param>
            <param name="id">The identifier to assign.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Update(System.Object)">
            <summary>
            Update the given persistent instance.
            </summary>
            <param name="entity">The persistent instance to update.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Update(System.Object,NHibernate.LockMode)">
            <summary>
            Update the given persistent instance.
            Obtains the specified lock mode if the instance exists, implicitly
            checking whether the corresponding database entry still exists
            (throwing an OptimisticLockingFailureException if not found).
            </summary>
            <param name="entity">The persistent instance to update.</param>
            <param name="lockMode">The lock mode to obtain.</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.SaveOrUpdate(System.Object)">
            <summary>
            Save or update the given persistent instance,
            according to its id (matching the configured "unsaved-value"?).
            </summary>
            <param name="entity">Tthe persistent instance to save or update
            (to be associated with the Hibernate Session).</param>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.SaveOrUpdateCopy(System.Object)">
            <summary>
            Save or update the contents of given persistent object,
            according to its id (matching the configured "unsaved-value"?).
            Will copy the contained fields to an already loaded instance
            with the same id, if appropriate.
            </summary>
            <param name="entity">The persistent object to save or update.
            (<i>not</i> necessarily to be associated with the Hibernate Session)
            </param>
            <returns>The actually associated persistent object.
            (either an already loaded instance with the same id, or the given object)</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Merge(System.Object)">
            <summary>
            Copy the state of the given object onto the persistent object with the same identifier. 
            If there is no persistent instance currently associated with the session, it will be loaded.
            Return the persistent instance. If the given instance is unsaved, 
            save a copy of and return it as a newly persistent instance.
            The given instance does not become associated with the session. 
            This operation cascades to associated instances if the association is mapped with cascade="merge".
            The semantics of this method are defined by JSR-220. 
            </summary>
            <param name="entity">The persistent object to merge.
            (<i>not</i> necessarily to be associated with the Hibernate Session)
            </param>
            <returns>An updated persistent instance</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Get``1(System.Object)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or null if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <typeparam name="T">The object type to get.</typeparam>
            <param name="id">The id of the object to get.</param>
            <returns>the persistent instance, or null if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Get``1(System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity type
            with the given identifier, or null if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <typeparam name="T">The object type to get.</typeparam>
            <param name="id">The lock mode to obtain.</param>
            <param name="lockMode">The lock mode.</param>
            <returns>the persistent instance, or null if not found</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Load``1(System.Object)">
            <summary>
            Return the persistent instance of the given entity class
            with the given identifier, throwing an exception if not found.
            </summary>
            <typeparam name="T">The object type to load.</typeparam>
            <param name="id">An identifier of the persistent instance.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Load``1(System.Object,NHibernate.LockMode)">
            <summary>
            Return the persistent instance of the given entity class
             with the given identifier, throwing an exception if not found.
            Obtains the specified lock mode if the instance exists.
            </summary>
            <typeparam name="T">The object type to load.</typeparam>
            <param name="id">An identifier of the persistent instance.</param>
            <param name="lockMode">The lock mode.</param>
            <returns>The persistent instance</returns>
            <exception cref="T:Spring.Dao.ObjectRetrievalFailureException">If not found</exception>     
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.LoadAll``1">
            <summary>
            Return all persistent instances of the given entity class.
            Note: Use queries or criteria for retrieving a specific subset.
            </summary>
            <typeparam name="T">The object type to load.</typeparam>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Find``1(System.String)">
            <summary>
            Execute a query for persistent instances.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Find``1(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a "?" parameter in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">the value of the parameter</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Find``1(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding one value
            to a "?" parameter of the given type in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="value">The value of the parameter.</param>
            <param name="type">Hibernate type of the parameter (or null)</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Find``1(System.String,System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">a query expressed in Hibernate's query language</param>
            <param name="values">the values of the parameters</param>
            <returns>a generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Find``1(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a number of
            values to "?" parameters of the given types in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>
            a generic List containing 0 or more persistent instances
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>  
            <exception cref="T:System.ArgumentException">If values and types are not null and their lengths are not equal</exception>  
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedParam``1(System.String,System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a  named parameter in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>a generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedParam``1(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a query for persistent instances, binding
            one value to a  named parameter in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">The name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedParam``1(System.String,System.String[],System.Object[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to  named parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedParam``1(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a query for persistent instances, binding a
            number of values to  named parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQuery``1(System.String)">
            <summary>
            Execute a named query for persistent instances.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQuery``1(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
             A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQuery``1(System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a "?" parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="value">The value of the parameter</param>
            <param name="type">Hibernate type of the parameter (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQuery``1(System.String,System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQuery``1(System.String,System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding a
            number of values to "?" parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="values">The values of the parameters</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If values and types are not null and their lengths differ.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQueryAndNamedParam``1(System.String,System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a  named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQueryAndNamedParam``1(System.String,System.String,System.Object,NHibernate.Type.IType)">
            <summary>
            Execute a named query for persistent instances, binding
            one value to a  named parameter in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramName">Name of the parameter</param>
            <param name="value">The value of the parameter</param>
            <param name="type">The Hibernate type of the parameter (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQueryAndNamedParam``1(System.String,System.String[],System.Object[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to  named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQueryAndNamedParam``1(System.String,System.String[],System.Object[],NHibernate.Type.IType[])">
            <summary>
            Execute a named query for persistent instances, binding
            number of values to  named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="paramNames">The names of the parameters</param>
            <param name="values">The values of the parameters.</param>
            <param name="types">Hibernate types of the parameters (or null)</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If paramNames length is not equal to values length or
            if paramNames length is not equal to types length (when types is not null)</exception>        
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByNamedQueryAndValueObject``1(System.String,System.Object)">
            <summary>
            Execute a named query for persistent instances, binding the properties
            of the given object to  named parameters in the query string.
            A named query is defined in a Hibernate mapping file.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryName">The name of a Hibernate query in a mapping file</param>
            <param name="valueObject">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.FindByValueObject``1(System.String,System.Object)">
            <summary>
            Execute a query for persistent instances, binding the properties
            of the given object to <i>named</i> parameters in the query string.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="queryString">A query expressed in Hibernate's query language</param>       
            <param name="valueObject">The values of the parameters</param>
            <returns>A generic List containing 0 or more persistent instances</returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Execute``1(Spring.Data.NHibernate.Generic.HibernateDelegate{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="del">The delegate callback object that specifies the Hibernate action.</param>
            <returns>a result object returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Execute``1(Spring.Data.NHibernate.Generic.HibernateDelegate{``0},System.Boolean)">
            <summary>
            Execute the action specified by the delegate within a Session.
            </summary>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="del">The HibernateDelegate that specifies the action
            to perform.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>a result object returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Execute``1(Spring.Data.NHibernate.Generic.IHibernateCallback{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="action">The callback object that specifies the Hibernate action.</param>
            <returns>
            a result object returned by the action, or null
            </returns>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.Execute``1(Spring.Data.NHibernate.Generic.IHibernateCallback{``0},System.Boolean)">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <typeparam name="T">The object type retrieved.</typeparam>
            <param name="action">callback object that specifies the Hibernate action.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>
            a result object returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.ExecuteFind``1(Spring.Data.NHibernate.Generic.IFindHibernateCallback{``0},System.Boolean)">
            <summary>
            Execute the action specified by the given action object within a Session assuming that an IList is returned.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="action">callback object that specifies the Hibernate action.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>
            an IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.ExecuteFind``1(Spring.Data.NHibernate.Generic.FindHibernateDelegate{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="del">The delegate callback object that specifies the Hibernate action.</param>
            <returns>A generic IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.ExecuteFind``1(Spring.Data.NHibernate.Generic.FindHibernateDelegate{``0},System.Boolean)">
            <summary>
            Execute the action specified by the delegate within a Session.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="del">The FindHibernateDelegate that specifies the action
            to perform.</param>
            <param name="exposeNativeSession">if set to <c>true</c> expose the native hibernate session to
            callback code.</param>
            <returns>A generic IList returned by the action, or null
            </returns>
            <exception cref="T:Spring.Dao.DataAccessException">In case of Hibernate errors</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.HibernateTemplate.ExecuteFind``1(Spring.Data.NHibernate.Generic.IFindHibernateCallback{``0})">
            <summary>
            Execute the action specified by the given action object within a Session.
            </summary>
            <typeparam name="T">The object type to find.</typeparam>
            <param name="action">The callback object that specifies the Hibernate action.</param>
            <returns>
            A generic IList returned by the action, or null
            </returns>
            <remarks>
            Application exceptions thrown by the action object get propagated to the
            caller (can only be unchecked). Hibernate exceptions are transformed into
            appropriate DAO ones. Allows for returning the result object.
            <p>Note: Callback code is not supposed to handle transactions itself!
            Use an appropriate transaction manager like HibernateTransactionManager.
            Generally, callback code must not touch any Session lifecycle methods,
            like close, disconnect, or reconnect, to let the template do its work.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.AllowCreate">
            <summary>
            Gets or sets if a new Session should be created when no transactional Session
            can be found for the current thread.
            </summary>
            <value>
            	<c>true</c> if allowed to create non-transaction session;
            otherwise, <c>false</c>.
            </value>
            <remarks>
            	<p>HibernateTemplate is aware of a corresponding Session bound to the
            current thread, for example when using HibernateTransactionManager.
            If allowCreate is true, a new non-transactional Session will be created
            if none found, which needs to be closed at the end of the operation.
            If false, an InvalidOperationException will get thrown in this case.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.AlwaysUseNewSession">
            <summary>
            Gets or sets a value indicating whether to always
            use a new Hibernate Session for this template.
            </summary>
            <value><c>true</c> if always use new session; otherwise, <c>false</c>.</value>
            <remarks>
            	<p>
            Default is "false"; if activated, all operations on this template will
            work on a new NHibernate ISession even in case of a pre-bound ISession
            (for example, within a transaction).
            </p>
            	<p>Within a transaction, a new NHibernate ISession used by this template
            will participate in the transaction through using the same ADO.NET
            Connection. In such a scenario, multiple Sessions will participate
            in the same database transaction.
            </p>
            	<p>Turn this on for operations that are supposed to always execute
            independently, without side effects caused by a shared NHibernate ISession.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.ExposeNativeSession">
            <summary>
            Set whether to expose the native Hibernate Session to IHibernateCallback
            code. Default is "false": a Session proxy will be returned,
            suppressing <code>close</code> calls and automatically applying
            query cache settings and transaction timeouts.
            </summary>
            <value><c>true</c> if expose native session; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.TemplateFlushMode">
            <summary>
            Gets or sets the template flush mode.
            </summary>
            <remarks>
            Default is Auto. Will get applied to any <b>new</b> ISession
            created by the template.
            </remarks>
            <value>The template flush mode.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.EntityInterceptor">
            <summary>
            Gets or sets the entity interceptor that allows to inspect and change
            property values before writing to and reading from the database.
            </summary>
            <remarks>
            Will get applied to any <b>new</b> ISession created by this object.
            <p>Such an interceptor can either be set at the ISessionFactory level,
            i.e. on LocalSessionFactoryObject, or at the ISession level, i.e. on
            HibernateTemplate, HibernateInterceptor, and HibernateTransactionManager.
            It's preferable to set it on LocalSessionFactoryObject or HibernateTransactionManager
            to avoid repeated configuration and guarantee consistent behavior in transactions.
            </p>
            </remarks>
            <value>The interceptor.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.EntityInterceptorObjectName">
            <summary>
            Set the object name of a Hibernate entity interceptor that allows to inspect
            and change property values before writing to and reading from the database.
            </summary>
            <remarks>
            Will get applied to any new Session created by this transaction manager.
            <p>Requires the object factory to be known, to be able to resolve the object
            name to an interceptor instance on session creation. Typically used for
            prototype interceptors, i.e. a new interceptor instance per session.
            </p>
            <p>Can also be used for shared interceptor instances, but it is recommended
            to set the interceptor reference directly in such a scenario.
            </p>
            </remarks>
            <value>The name of the entity interceptor in the object factory/application context.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.SessionFactory">
            <summary>
            Gets or sets the session factory that should be used to create
            NHibernate ISessions.
            </summary>
            <value>The session factory.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.ObjectFactory">
            <summary>
            Set the object factory instance.
            </summary>
            <value>The object factory instance</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.CacheQueries">
            <summary>
            Gets or sets a value indicating whether to 
            cache all queries executed by this template.
            </summary>
            <remarks>
            If this is true, all IQuery and ICriteria objects created by
            this template will be marked as cacheable (including all
            queries through find methods).
            <p>To specify the query region to be used for queries cached
            by this template, set the QueryCacheRegion property.
            </p>
            </remarks>
            <value><c>true</c> if cache queries; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.QueryCacheRegion">
            <summary>
            Gets or sets the name of the cache region for queries executed by this template.
            </summary>
            <remarks>
            If this is specified, it will be applied to all IQuery and ICriteria objects
            created by this template (including all queries through find methods).
            <p>The cache region will not take effect unless queries created by this
            template are configured to be cached via the CacheQueries property.
            </p>
            </remarks>
            <value>The query cache region.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.FetchSize">
            <summary>
            Gets or sets the fetch size for this HibernateTemplate.
            </summary>
            <value>The size of the fetch.</value>
            <remarks>This is important for processing
            large result sets: Setting this higher than the default value will increase
            processing speed at the cost of memory consumption; setting this lower can
            avoid transferring row data that will never be read by the application.
            <p>Default is 0, indicating to use the driver's default.</p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.MaxResults">
            <summary>
            Gets or sets the maximum number of rows for this HibernateTemplate.
            </summary>
            <value>The max results.</value>
            <remarks>
            This is important
            for processing subsets of large result sets, avoiding to read and hold
            the entire result set in the database or in the ADO.NET driver if we're
            never interested in the entire result in the first place (for example,
            when performing searches that might return a large number of matches).
            <p>Default is 0, indicating to use the driver's default.</p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.AdoExceptionTranslator">
            <summary>
            Set the ADO.NET exception translator for this instance.
            Applied to System.Data.Common.DbException (or provider specific exception type
            in .NET 1.1) thrown by callback code, be it direct
            DbException or wrapped Hibernate ADOExceptions.
            <p>The default exception translator is either a ErrorCodeExceptionTranslator
            if a DbProvider is available, or a FalbackExceptionTranslator otherwise
            </p>
            </summary>
            <value>The ADO exception translator.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.ClassicHibernateTemplate">
            <summary>
            Gets the classic hibernate template for access to non-generic methods.
            </summary>
            <value>The classic hibernate template.</value>
        </member>
        <member name="P:Spring.Data.NHibernate.Generic.HibernateTemplate.ProxyFactory">
            <summary>
            Gets or sets the proxy factory.
            </summary>
            <remarks>This may be useful to set if you create many instances of 
            HibernateTemplate and/or HibernateDaoSupport.  This allows the same
            ProxyFactory implementation to be used thereby limiting the
            number of dynamic proxy types created in the temporary assembly, which
            are never garbage collected due to .NET runtime semantics.
            </remarks>
            <value>The proxy factory.</value>
        </member>
        <member name="T:Spring.Data.NHibernate.Generic.IHibernateCallback`1">
            <summary>
            Callback interface (Generic version) for NHibernate code.
            </summary>
            <typeparam name="T">The type of result object</typeparam>
            <remarks>To be used with HibernateTemplate execute
            method. The typical implementation will call 
            Session.load/find/save/update to perform
            some operations on persistent objects.
            </remarks>
            
            <author>Sree Nivask (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
            <returns>A result object.</returns>        
            <param name="session">The active Hibernate session</param>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.GetByTypeHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.LoadByTypeHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="T:Spring.Data.NHibernate.Generic.IFindHibernateCallback`1">
            <summary>
            Callback interface (Generic version) for NHibernate code that
            returns a List of objects.
            </summary>
            <typeparam name="T">The type of result object</typeparam>
            <remarks>To be used with HibernateTemplate execute
            method. The typical implementation will call 
            Session.load/find/save/update to perform
            some operations on persistent objects.
            </remarks>
            <author>Sree Nivask (.NET)</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.IFindHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
            <returns>Collection result object.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.LoadAllByTypeHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.FindHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.FindByNamedParamHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.FindByNamedQueryHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.FindByNamedQueryAndNamedParamHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.Generic.FindByNamedQueryAndValueObjectHibernateCallback`1.DoInHibernate(NHibernate.ISession)">
            <summary>
            Gets called by HibernateTemplate with an active
            Hibernate Session. Does not need to care about activating or closing
            the Session, or handling transactions.
            </summary>
            <remarks>
            <p>
            Allows for returning a result object created within the callback, i.e.
            a domain object or a collection of domain objects. Note that there's
            special support for single step actions: see HibernateTemplate.find etc.
            </p>
            </remarks>
        </member>
        <member name="T:Spring.Data.NHibernate.SessionFactoryUtils">
            <summary>
             Helper class featuring methods for Hibernate Session handling,
             allowing for reuse of Hibernate Session instances within transactions.
             Also provides support for exception translation.
            </summary>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.SessionFactoryUtils.log">
            <summary>
            The <see cref="T:Common.Logging.ILog"/> instance for this class. 
            </summary>
        </member>
        <member name="F:Spring.Data.NHibernate.SessionFactoryUtils.SESSION_SYNCHRONIZATION_ORDER">
            <summary>
            The ordering value for synchronizaiton this session resources.
            Set to be lower than ADO.NET synchronization.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.SessionFactoryUtils"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.GetNewSession(NHibernate.ISessionFactory,NHibernate.IInterceptor)">
            <summary>
            Get a new Hibernate Session from the given SessionFactory.
            Will return a new Session even if there already is a pre-bound
            Session for the given SessionFactory.
            </summary>
            <remarks>
            Within a transaction, this method will create a new Session
            that shares the transaction's ADO.NET Connection. More specifically,
            it will use the same ADO.NET Connection as the pre-bound Hibernate Session.
            </remarks>
            <param name="sessionFactory">The session factory to create the session with.</param>
            <param name="interceptor">The Hibernate entity interceptor, or <code>null</code> if none.</param>
            <returns>The new session.</returns>
            <exception cref="T:Spring.Dao.DataAccessResourceFailureException">If could not open Hibernate session</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.GetSession(NHibernate.ISessionFactory,NHibernate.IInterceptor,Spring.Data.Support.IAdoExceptionTranslator)">
            <summary>
            Get a Hibernate Session for the given SessionFactory. Is aware of and will
            return any existing corresponding Session bound to the current thread, for
            example when using HibernateTransactionManager. Will always create a new
            Session otherwise.
            </summary>
            <remarks>
            Supports setting a Session-level Hibernate entity interceptor that allows
            to inspect and change property values before writing to and reading from the
            database. Such an interceptor can also be set at the SessionFactory level
            (i.e. on LocalSessionFactoryObject), on HibernateTransactionManager, or on
            HibernateInterceptor/HibernateTemplate.
            </remarks>
            <param name="sessionFactory">The session factory to create the
            session with.</param>
            <param name="entityInterceptor">Hibernate entity interceptor, or <code>null</code> if none.</param>
            <param name="adoExceptionTranslator"> AdoExceptionTranslator to use for flushing the
            Session on transaction synchronization (can be <code>null</code>; only used when actually
            registering a transaction synchronization).</param>
            <returns>The Hibernate Session</returns>
            <exception cref="T:Spring.Dao.DataAccessResourceFailureException">
            If the session couldn't be created.
            </exception>
            <exception cref="T:System.InvalidOperationException">
            If no thread-bound Session found and allowCreate is false.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.GetSession(NHibernate.ISessionFactory,System.Boolean)">
            <summary>
            Get a Hibernate Session for the given SessionFactory. Is aware of and will
            return any existing corresponding Session bound to the current thread, for
            example when using <see cref="T:Spring.Data.NHibernate.HibernateTransactionManager"/>. Will create a new Session
            otherwise, if allowCreate is true.
            </summary>
            <param name="sessionFactory">The session factory to create the session with.</param>
            <param name="allowCreate">if set to <c>true</c> create a non-transactional Session when no
            transactional Session can be found for the current thread.</param>
            <returns>The hibernate session</returns>
            <exception cref="T:Spring.Dao.DataAccessResourceFailureException">
            If the session couldn't be created.
            </exception>
            <exception cref="T:System.InvalidOperationException">
            If no thread-bound Session found and allowCreate is false.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.DoGetSession(NHibernate.ISessionFactory,System.Boolean)">
            <summary>
            Get a Hibernate Session for the given SessionFactory.
            </summary>
            <remarks>Is aware of and will return any existing corresponding
            Session bound to the current thread, for example whenusing
            <see cref="T:Spring.Data.NHibernate.HibernateTransactionManager"/>.  Will create a new 
            Session otherwise, if "allowCreate" is true.
            <p>Throws the orginal HibernateException, in contrast to
            <see cref="M:Spring.Data.NHibernate.SessionFactoryUtils.GetSession(NHibernate.ISessionFactory,System.Boolean)"/>.
            </p></remarks>
            <param name="sessionFactory">The session factory.</param>
            <param name="allowCreate">if set to <c>true</c> [allow create].</param>
            <returns>The Hibernate Session</returns>
            <exception cref="T:NHibernate.HibernateException">
            if the Session couldn't be created
            </exception>
            <exception cref="T:System.InvalidOperationException">
            If no thread-bound Session found and allowCreate is false.
            </exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.OpenSession(NHibernate.ISessionFactory,NHibernate.IInterceptor)">
            <summary>
            Open a new Session from the factory.
            </summary>
            <param name="sessionFactory">The session factory to create the session with.</param>
            <param name="entityInterceptor">Hibernate entity interceptor, or <code>null</code> if none.</param>
            <returns>the newly opened session</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.CloseSession(NHibernate.ISession)">
            <summary>
            Perform the actual closing of the Hibernate Session
            catching and logging any cleanup exceptions thrown.
            </summary>
            <param name="session">The hibernate session to close</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.IsSessionTransactional(NHibernate.ISession,NHibernate.ISessionFactory)">
            <summary>
            Return whether the given Hibernate Session is transactional, that is,
            bound to the current thread by Spring's transaction facilities.
            </summary>
            <param name="session">The hibernate session to check</param>
            <param name="sessionFactory">The session factory that the session
            was created with, can be null.</param>
            <returns>
            	<c>true</c> if the session transactional; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.ConvertAdoAccessException(Spring.Data.Support.IAdoExceptionTranslator,NHibernate.ADOException)">
            <summary>
            Converts a Hibernate ADOException to a Spring DataAccessExcption, extracting the underlying error code from 
            ADO.NET.  Will extract the ADOException Message and SqlString properties and pass them to the translate method
            of the provided IAdoExceptionTranslator.
            </summary>
            <param name="translator">The IAdoExceptionTranslator, may be a user provided implementation as configured on
            HibernateTemplate.
            </param>
            <param name="ex">The ADOException throw</param>
            <returns>The translated DataAccessException or UncategorizedAdoException in case of an error in translation
            itself.</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.ConvertHibernateAccessException(NHibernate.HibernateException)">
            <summary>
            Convert the given HibernateException to an appropriate exception from the
            <code>Spring.Dao</code> hierarchy. Note that it is advisable to
            handle AdoException specifically by using a AdoExceptionTranslator for the
            underlying ADO.NET exception.
            </summary>
            <param name="ex">The Hibernate exception that occured.</param>
            <returns>DataAccessException instance</returns>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.ReleaseSession(NHibernate.ISession,NHibernate.ISessionFactory)">
            <summary>
            Close the given Session, created via the given factory,
            if it is not managed externally (i.e. not bound to the thread).
            </summary>
            <param name="session">The hibernate session to close</param>
            <param name="sessionFactory">The hibernate SessionFactory that
            the session was created with.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.CloseSessionOrRegisterDeferredClose(NHibernate.ISession,NHibernate.ISessionFactory)">
            <summary>
            Close the given Session or register it for deferred close.
            </summary>
            <param name="session">The session.</param>
            <param name="sessionFactory">The session factory.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.InitDeferredClose(NHibernate.ISessionFactory)">
             <summary>
            Initialize deferred close for the current thread and the given SessionFactory.
             Sessions will not be actually closed on close calls then, but rather at a
             processDeferredClose call at a finishing point (like request completion).
             </summary>
             <param name="sessionFactory">The session factory.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.IsDeferredCloseActive(NHibernate.ISessionFactory)">
            <summary>
            Return if deferred close is active for the current thread
            and the given SessionFactory.</summary>
            <param name="sessionFactory">The session factory.</param>
            <returns>
            	<c>true</c> if [is deferred close active] [the specified session factory]; otherwise, <c>false</c>.
            </returns>
            <exception cref="T:System.ArgumentNullException">If SessionFactory argument is null.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.ProcessDeferredClose(NHibernate.ISessionFactory)">
            <summary>
            Process Sessions that have been registered for deferred close
            for the given SessionFactory.
            </summary>
            <param name="sessionFactory">The session factory.</param>
            <exception cref="T:System.InvalidOperationException">If there is no session factory associated with the thread.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.ApplyTransactionTimeout(NHibernate.ICriteria,NHibernate.ISessionFactory)">
            <summary>
            Applies the current transaction timeout, if any, to the given
            criteria object
            </summary>
            <param name="criteria">The Hibernate Criteria object.</param>
            <param name="sessionFactory">Hibernate SessionFactory that the Criteria was created for
            (can be <code>null</code>).</param>
            <exception cref="T:System.ArgumentNullException">If criteria argument is null.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.ApplyTransactionTimeout(NHibernate.IQuery,NHibernate.ISessionFactory)">
            <summary>
            Applies the current transaction timeout, if any, to the given
            Hibenrate query object.
            </summary>
            <param name="query">The Hibernate Query object.</param>
            <param name="sessionFactory">Hibernate SessionFactory that the Query was created for
            (can be <code>null</code>).</param>
            <exception cref="T:System.ArgumentNullException">If query argument is null.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.GetDbProvider(NHibernate.ISessionFactory)">
            <summary>
            Gets the Spring IDbProvider given the ISessionFactory.
            </summary>
            <remarks>The matching is performed by comparing the assembly qualified
            name string of the hibernate Driver.ConnectionType to those in
            the DbProviderFactory definitions.  No connections are created
            in performing this comparison.</remarks>
            <param name="sessionFactory">The session factory.</param>
            <returns>The corresponding IDbProvider, null if no mapping was found.</returns>
            <exception cref="T:System.InvalidOperationException">If DbProviderFactory's ApplicaitonContext is not
            an instance of IConfigurableApplicaitonContext.</exception>
        </member>
        <member name="M:Spring.Data.NHibernate.SessionFactoryUtils.NewAdoExceptionTranslator(NHibernate.ISessionFactory)">
            <summary>
            Create a IAdoExceptionTranslator from the given SessionFactory.
            </summary>
            <remarks>If a corresponding IDbProvider is found, a ErrorcodeExceptionTranslator
            for the IDbProvider is created.  Otherwise, a FallbackException is created.</remarks>
            <param name="sessionFactory">The session factory to create the translator for</param>
            <returns>An IAdoExceptionTranslator</returns>
        </member>
        <member name="T:Spring.Data.NHibernate.SpringSessionContext">
            <summary>
            Implementation of NHibernates 1.2's ICurrentSessionContext interface
            that delegates to Spring's SessionFactoryUtils for providing a
            Spirng-managed current Session.
            </summary>
            <remarks>Used by Spring's LocalSessionFactoryBean if told to expose
            a transaction-aware SessionFactory.
            <p>This ICurrentSessionContext implementation can also be specified in
            custom ISessionFactory setup through the 
            "hibernate.current_session_context_class" property, with the fully
            qualified name of this class as value.</p></remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
            <see cref="M:Spring.Data.NHibernate.SessionFactoryUtils.DoGetSession(NHibernate.ISessionFactory,System.Boolean)"/>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionContext.#ctor(NHibernate.Engine.ISessionFactoryImplementor)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.SpringSessionContext"/> class
            </summary>
            <param name="sessionFactory">The NHibernate session factory.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionContext.CurrentSession">
            <summary>
            Retrieve the Spring-managed Session for the current thread.
            </summary>
            <returns>Current session associated with the thread</returns>
            <exception cref="T:NHibernate.HibernateException">On errors retrieving thread bound session.</exception>
        </member>
        <member name="T:Spring.Data.NHibernate.SpringSessionSynchronization">
            <summary>
            NHibnerations actions taken during the transaction lifecycle.
            </summary>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Data.NHibernate.SpringSessionSynchronization.log">
            <summary>
            The <see cref="T:Common.Logging.ILog"/> instance for this class. 
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionSynchronization.#ctor(Spring.Data.NHibernate.SessionHolder,NHibernate.ISessionFactory,Spring.Data.Support.IAdoExceptionTranslator,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.SpringSessionSynchronization"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionSynchronization.Suspend">
            <summary>
            Suspend this synchronization. 
            </summary>
            <remarks>
            <p>
            Unbind Hibernate resources (SessionHolder) from
            <see cref="T:Spring.Transaction.Support.TransactionSynchronizationManager"/>
            if managing any.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionSynchronization.Resume">
            <summary>
            Resume this synchronization.
            </summary>
            <remarks>
            <p>
            Rebind Hibernate resources from 
            <see cref="T:Spring.Transaction.Support.TransactionSynchronizationManager"/>
            if managing any.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionSynchronization.BeforeCommit(System.Boolean)">
            <summary>
            Invoked before transaction commit (before
            <see cref="M:Spring.Transaction.Support.ITransactionSynchronization.BeforeCompletion"/>)
            </summary>
            <param name="readOnly">
            If the transaction is defined as a read-only transaction.
            </param>
            <remarks>
            <p>
            Can flush transactional sessions to the database.
            </p>
            <p>
            Note that exceptions will get propagated to the commit caller and 
            cause a rollback of the transaction.
            </p>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionSynchronization.BeforeCompletion">
            <summary>
            Invoked before transaction commit (before
            <see cref="M:Spring.Transaction.Support.ITransactionSynchronization.BeforeCompletion"/>)
            Can e.g. flush transactional O/R Mapping sessions to the database
            </summary>
            <remarks>
            <para>
            This callback does not mean that the transaction will actually be
            commited.  A rollback decision can still occur after this method
            has been called.  This callback is rather meant to perform work 
            that's only relevant if a commit still has a chance
            to happen, such as flushing SQL statements to the database.
            </para>
            <para>
            Note that exceptions will get propagated to the commit caller and cause a
            rollback of the transaction.</para>
            <para>
            (note: do not throw TransactionException subclasses here!)
            </para>
            </remarks>
        </member>
        <member name="M:Spring.Data.NHibernate.SpringSessionSynchronization.AfterCompletion(Spring.Transaction.Support.TransactionSynchronizationStatus)">
            <summary>
            Invoked after transaction commit/rollback.
            </summary>
            <param name="status">
            Status according to <see cref="T:Spring.Transaction.Support.TransactionSynchronizationStatus"/>
            </param>
            <remarks>
            Can e.g. perform resource cleanup, in this case after transaction completion.
            <p>
            Note that exceptions will get propagated to the commit or rollback
            caller, although they will not influence the outcome of the transaction.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Data.NHibernate.SpringSessionSynchronization.Order">
            <summary>
            Return the order value of this object, where a higher value means greater in
            terms of sorting.
            </summary>
            <remarks>
            <p>
            Normally starting with 0 or 1, with <see cref="F:System.Int32.MaxValue"/> indicating
            greatest. Same order values will result in arbitrary positions for the affected
            objects.
            </p>
            <p>
            Higher value can be interpreted as lower priority, consequently the first object
            has highest priority.
            </p>
            </remarks>
            <returns>The order value.</returns>
        </member>
        <member name="T:Spring.Data.NHibernate.FilterDefinitionFactoryObject">
            <summary>
            Convenient FactoryObject for defining Hibernate FilterDefinitions.
            Exposes a corresponding Hibernate FilterDefinition object.
            </summary>
            <remarks>
            
            <p>
            Typically defined as an inner object within a LocalSessionFactoryObject
            definition, as the list element for the "filterDefinitions" object property.
            For example:
            </p>
            
            <pre>
            &lt;objectn id="sessionFactory" type="Spring.Data.NHibernate.LocalSessionFactoryObject, Spring.Data.NHibernate"&gt;
              ...
              &lt;property name="FilterDefinitions"&gt;
               &lt;list&gt;
                  &lt;object type="Spring.Data.NHibernate.FilterDefinitionFactoryObject, Spring.Data.NHibernate"&gt;
                    &lt;property name="FilterName" value="myFilter"/&gt;
                    &lt;property name="ParameterTypes"&gt;
                      &lt;props&gt;
                        &lt;prop key="MyParam"&gt;string&lt;/prop&gt;
                        &lt;prop key="MyOtherParam"&gt;long&lt;/prop&gt;
                      &lt;/props&gt;
                    &lt;/property&gt;
                  &lt;/object&gt;
                &lt;/list&gt;
              &lt;/property&gt;
              ...
            &lt;/object&gt;
            </pre>
            <p>
            Alternatively, specify an object id (or name) attribute for the inner object,
            instead of the "FilterName" property.
            </p>
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Marko Lahma (.NET)</author>
            <see cref="T:NHibernate.Engine.FilterDefinition"/>
            <see cref="P:Spring.Data.NHibernate.LocalSessionFactoryObject.FilterDefinitions"/>
            <version>$Id: FilterDefiniitionFactoryObject.cs,v 1.1 2008/04/07 20:12:53 lahma Exp $</version>
        </member>
        <member name="M:Spring.Data.NHibernate.FilterDefinitionFactoryObject.AfterPropertiesSet">
            <summary>
            Initializes the filter definitions.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.FilterDefinitionFactoryObject.GetObject">
            <summary>
            Returns the singleton filter definition.
            </summary>
            <returns></returns>
        </member>
        <member name="P:Spring.Data.NHibernate.FilterDefinitionFactoryObject.FilterName">
            <summary>
            Set the name of the filter.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.FilterDefinitionFactoryObject.ParameterTypes">
            <summary>
            Set the parameter types for the filter,
            with parameter names as keys and type names as values.
            <see cref="M:NHibernate.Type.TypeFactory.HeuristicType(System.String)"/>
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.FilterDefinitionFactoryObject.DefaultFilterCondition">
            <summary>
            Specify a default filter condition for the filter, if any.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.FilterDefinitionFactoryObject.ObjectName">
            <summary>
            If no explicit filter name has been specified, the object name of
            the FilterDefinitionFactoryObject will be used.
            <see cref="P:Spring.Data.NHibernate.FilterDefinitionFactoryObject.FilterName"/>
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.FilterDefinitionFactoryObject.ObjectType">
            <summary>
            Returns the type of the object this factory produces.
            </summary>
        </member>
        <member name="P:Spring.Data.NHibernate.FilterDefinitionFactoryObject.IsSingleton">
            <summary>
            Returns whether this factory produces singletons, always true.
            </summary>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException">
            <summary>
            Hibernate-specific subclass of ObjectRetrievalFailureException.
            </summary>	 
            <remarks>
            Converts Hibernate's UnresolvableObjectException, ObjectNotFoundException,
            ObjectDeletedException, and WrongClassException.
            </remarks>
            <author>Mark Pollack (.NET)</author>
            <version>$Id: HibernateObjectRetrievalFailureException.cs,v 1.1 2008/04/07 20:12:53 lahma Exp $</version>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException"/> class.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor(NHibernate.UnresolvableObjectException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException"/> class.
            </summary>
            <param name="ex">The ex.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor(NHibernate.ObjectNotFoundException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException"/> class.
            </summary>
            <param name="ex">The ex.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor(NHibernate.ObjectDeletedException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException"/> class.
            </summary>
            <param name="ex">The ex.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor(NHibernate.WrongClassException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException"/> class.
            </summary>
            <param name="ex">The ex.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor(System.String,System.Exception)">
            <summary>
            Creates a new instance of the HibernateObjectRetrievalFailureException class with the specified message
            and root cause.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception that is being wrapped.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateObjectRetrievalFailureException"/> class.
            </summary>
            <param name="info">
            The <see cref="T:System.Runtime.Serialization.SerializationInfo"/>
            that holds the serialized object data about the exception being thrown.
            </param>
            <param name="context">
            The <see cref="T:System.Runtime.Serialization.StreamingContext"/>
            that contains contextual information about the source or destination.
            </param>
        </member>
        <member name="T:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException">
            <summary>
            Hibernate-specific subclass of ObjectOptimisticLockingFailureException.
            </summary>
            <remarks>
            Converts Hibernate's StaleObjectStateException.
            </remarks>
            <author>Mark Pollack (.NET)</author>
            <version>$Id: HibernateOptimisticLockingFailureException.cs,v 1.2 2008/04/23 11:41:41 lahma Exp $</version>
            
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException"/> class.
            </summary>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException.#ctor(System.String)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException"/> class.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException.#ctor(NHibernate.StaleObjectStateException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException"/> class.
            </summary>
            <param name="ex">The ex.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException.#ctor(NHibernate.StaleStateException)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException"/> class.
            </summary>
            <param name="ex">The StaleStateException.</param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException.#ctor(System.String,System.Exception)">
            <summary>
            Creates a new instance of the HibernateOptimisticLockingFailureException class with the specified message
            and root cause.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception that is being wrapped.
            </param>
        </member>
        <member name="M:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Creates a new instance of the
            <see cref="T:Spring.Data.NHibernate.HibernateOptimisticLockingFailureException"/> class.
            </summary>
            <param name="info">
            The <see cref="T:System.Runtime.Serialization.SerializationInfo"/>
            that holds the serialized object data about the exception being thrown.
            </param>
            <param name="context">
            The <see cref="T:System.Runtime.Serialization.StreamingContext"/>
            that contains contextual information about the source or destination.
            </param>
        </member>
    </members>
</doc>