From 737fa1def4328d71bada601a2f0f4b2017c1eee0 Mon Sep 17 00:00:00 2001
From: Sam Brannen <sam@sambrannen.com>
Date: Fri, 16 Oct 2009 21:29:30 +0000
Subject: [PATCH] Corrected minor errors regarding JDO, grammar, etc.

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@2137 50f2f4bb-b051-0410-bef5-90022cba6387
---
 spring-framework-reference/src/orm.xml | 28 ++++++++++++--------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/spring-framework-reference/src/orm.xml b/spring-framework-reference/src/orm.xml
index ace62bbf637..a83ada75fb8 100644
--- a/spring-framework-reference/src/orm.xml
+++ b/spring-framework-reference/src/orm.xml
@@ -7,16 +7,14 @@
   <section id="orm-introduction">
     <title>Introduction to ORM with Spring</title>
 
-    <para>The Spring Framework supports <!--Changed from *provides* to *supports* because *provides* is too vague. If the integration is something you configure, then say *supports*.--><!--If Spring is preconfigured with integration support, say it *includes* integration with.But it sounds like it's *supports* because --><!--later in paragraph it refers to configuring support packages. TR: OK-->integration
+    <para>The Spring Framework supports integration
     with Hibernate, Java Persistence API (JPA), Java Data Objects (JDO) and
     iBATIS SQL Maps for resource management, data access object (DAO)
-    implementation, and transaction strategies. For example for Hibernate,
-    there is first-class support with lots of IoC convenience features,
-    addressing many typical Hibernate integration issues. You can configure
-    all of these supported features for O/R (object relational) mappers <!--GLOBAL: I have changed O/R mapping to ORM, to make all reference consistent and to be consistent with name of chapter. But when you--><!--refer to *mappers* as you do above, it's O/R mappers. The M in ORM stands for *mapping*, not *mappers.*--><!--TR: OK -->through
-    Dependency Injection. <!--Identify *these support packages*. Do you mean Hibernate, JPA, etc? Is it correct to call them support packages? 
-TR: REVISED, PLS REVIEW. Changed to say features instead of packages. Reverted the "first-class support" sentence above since it is not 
-IoC itself providing the support.-->They can participate in Spring's resource
+    implementations, and transaction strategies. For example, for Hibernate
+    there is first-class support with several convenient IoC features that
+    address many typical Hibernate integration issues. You can configure
+    all of the supported features for O/R (object relational) mapping tools through
+    Dependency Injection. They can participate in Spring's resource
     and transaction management, and they comply with Spring's generic
     transaction and DAO exception hierarchies. The recommended integration
     style is to code DAOs against plain Hibernate, JPA, and JDO APIs. The
@@ -26,12 +24,12 @@ IoC itself providing the support.-->They can participate in Spring's resource
 
     <para>Spring adds significant enhancements to the ORM layer of your choice
     when you create data access applications. You can leverage as much of the
-    integration support as you wish and you should compare this integration
+    integration support as you wish, and you should compare this integration
     effort with the cost and risk of building a similar infrastructure
     in-house. You can use much of the ORM support as you would a library,
     regardless of technology, because everything is designed as a set of
-    reusable JavaBeans. ORM in a Spring IoC container does facilitate
-    configuration and deployment; thus most examples in this section show
+    reusable JavaBeans. ORM in a Spring IoC container facilitates
+    configuration and deployment. Thus most examples in this section show
     configuration inside a Spring container.</para>
 
     <para>Benefits of using the Spring Framework to create your ORM DAOs
@@ -1200,13 +1198,13 @@ TR: OK AS IS. Two different callback methhods - one is Spring's (*afterCompletio
       <title><interfacename>JdoDialect</interfacename></title>
 
       <para>As an advanced feature, both <classname>JdoTemplate</classname>
-      and <classname>interfacename</classname> support a custom
-      <interfacename>JdoDialect</interfacename>, to be passed into the
+      and <classname>JdoTransactionManager</classname> support a custom
+      <interfacename>JdoDialect</interfacename> that can be passed into the
       <code>jdoDialect</code> bean property. In this scenario, the DAOs will
       not receive a <interfacename>PersistenceManagerFactory</interfacename>
       reference but rather a full <classname>JdoTemplate</classname> instance
-      (for example, passed into the <code>jdo</code><code>Template</code>
-      property of <classname>JdoDaoSupport</classname>. Using a
+      (for example, passed into the <literal>jdoTemplate</literal>
+      property of <classname>JdoDaoSupport</classname>). Using a
       <interfacename>JdoDialect</interfacename> implementation, you can enable
       advanced features supported by Spring, usually in a vendor-specific
       manner:</para>