<?xml version='1.0' encoding='iso-8859-1'?>
<!-- User Guide -->
  <toc label="Dali Java Persistence Tools User Guide">
    <topic href="getting_started.htm" label="Getting started">
      <topic href="getting_started001.htm#BABEFHCD" label="Requirements and installation" />
      <topic href="getting_started002.htm#BABIGCJA" label="Dali quick start">
        <topic href="getting_started003.htm#BABDFHDA" label="Creating a new JPA project" />
        <topic href="getting_started004.htm#BABFGDDG" label="Creating a Java persistent entity with persistent fields" />
      </topic>
    </topic>
    <topic href="concepts.htm" label=" Concepts">
      <topic href="concept_persistence.htm#BABCAHIC" label="Understanding Java persistence" />
      <topic href="concept_mapping.htm#BABBDJFI" label="Understanding OR mappings" />
      <topic href="concepts001.htm#BABBGFJG" label="Understanding EJB 3.0 Java Persistence API">
        <topic href="concepts002.htm#CHDHAGIH" label="The persistence.xml file" />
        <topic href="concepts003.htm#CHDBIJAC" label="The orm.xml file" />
      </topic>
    </topic>
    <topic href="tasks.htm" label=" Tasks">
      <topic href="task_create_new_project.htm#CIHHEJCJ" label="Creating a new JPA project" />
      <topic href="tasks001.htm#BEIBADHH" label="Converting a Java Project to a JPA Project" />
      <topic href="task_create_jpa_entity.htm#BABFBJBG" label="Creating a JPA Entity" />
      <topic href="task_manage_persistence.htm#CIHDAJID" label="Managing the persistence.xml file">
        <topic href="tasks002.htm#CIHFEBAI" label="Synchronizing classes" />
      </topic>
      <topic href="task_manage_orm.htm#CIHDGDCD" label="Managing the orm.xml file">
        <topic href="tasks003.htm#sthref59" label="Creating an orm.xml file" />
        <topic href="tasks004.htm#CIHBCDCE" label="Working with orm.xml file" />
      </topic>
      <topic href="task_add_persistence.htm#BABHICAI" label="Adding persistence to a class">
        <topic href="tasks005.htm#BABGBIEE" label="Entity" />
        <topic href="tasks006.htm#BABFEICE" label="Embeddable" />
        <topic href="tasks007.htm#BABDAGCI" label="Mapped superclass" />
      </topic>
      <topic href="task_additonal_tables.htm#CIHGBIEI" label="Specifying additional tables" />
      <topic href="task_inheritance.htm#CIHCCCJD" label="Specifying entity inheritance" />
      <topic href="tasks008.htm#BABIGBGG" label="Creating Named Queries" />
      <topic href="task_mapping.htm#BABDGBIJ" label="Mapping an entity">
        <topic href="tasks009.htm#BABBABCE" label="Basic mapping" />
        <topic href="tasks010.htm#BABCBHDF" label="Embedded mapping" />
        <topic href="tasks011.htm#CIHDIAEE" label="Embedded ID mapping" />
        <topic href="tasks012.htm#BABGCBHG" label="ID mapping" />
        <topic href="tasks013.htm#BABEIEGD" label="Many-to-many mapping" />
        <topic href="tasks014.htm#BABHFAFJ" label="Many-to-one mapping" />
        <topic href="tasks015.htm#BABHGEBD" label="One-to-many mapping" />
        <topic href="tasks016.htm#BABFHBCJ" label="One-to-one mapping" />
        <topic href="tasks017.htm#BABHFHEI" label="Transient mapping" />
        <topic href="tasks018.htm#BABHIBII" label="Version mapping" />
      </topic>
      <topic href="tasks019.htm#BABBAGFI" label="Generating entities from tables" />
      <topic href="tasks020.htm#CIHJIGBE" label="Generating tables from entities" />
      <topic href="tasks021.htm#BABFAIBA" label="Validating mappings and reporting problems">
        <topic href="tasks022.htm#CIHFEDEI" label="Error messages" />
        <topic href="tasks023.htm#CIHGEAIJ" label="Warning messages" />
      </topic>
      <topic href="tasks024.htm#BABDBCBI" label="Modifying persistent project properties" />
    </topic>
    <topic label=" Reference">
      <topic label="Wizards">
        <topic href="ref_new_jpa_project_wizard.htm#CACBJGBG" label="Create New JPA Project wizard">
          <topic href="ref_new_jpa_project.htm#CACBJAGC" label="New JPA Project page" />
          <topic href="ref_java_page.htm#CIAGEBAA" label="Java Page" />
          <topic href="ref_jpa_facet.htm#CACIFDIF" label="JPA Facet page" />
        </topic>
        <topic href="ref_create_jpa_entity_wizard.htm#CIAGGGDF" label="Create JPA Entity wizard">
          <topic href="ref_EntityClassPage.htm#CIAFEIGF" label="Entity Class page" />
          <topic href="ref_EntityPropertiesPage.htm#CIADECIA" label="Entity Properties page" />
        </topic>
        <topic href="reference002.htm#CIAIJCCE" label="Mapping File Wizard">
          <topic href="reference003.htm#CIAJEIDJ" label="Mapping File" />
        </topic>
        <topic href="reference004.htm#CIAGHCGA" label="Generate Tables from Entities Wizard" />
        <topic href="ref_create_custom_entities_wizard.htm#CIAGBFJE" label="Generate Entities from Tables Wizard">
          <topic href="ref_selectTables.htm#CIAHCGEE" label="Select Tables" />
          <topic href="ref_tableAssociations.htm#CIACDICB" label="Table Associations" />
          <topic href="ref_customizeDefaultEntityGeneration.htm#CIAEJDBE" label="Customize Default Entity Generation" />
          <topic href="ref_customizIndividualEntities.htm#CIACIGEE" label="Customize Individual Entities" />
        </topic>
        <topic href="ref_create_new_association_wizard.htm#CIAFGHIF" label="Create New Association">
          <topic href="ref_association_table.htm#CIAGJHDC" label="Association Tables" />
          <topic href="ref_join_columns.htm#CIAEGEEG" label="Join Columns" />
          <topic href="ref_association_cardinality.htm#CIAFIIFH" label="Association Cardinality" />
        </topic>
      </topic>
      <topic label="Property pages">
        <topic href="ref_persistence_prop_view.htm#BABFAEBB" label="JPA Details view (for entities)">
          <topic href="reference006.htm#CACCAGGC" label="General information" />
          <topic href="reference007.htm#CACIJBGH" label="Attribute overrides" />
          <topic href="reference008.htm#CACBHIDA" label="Secondary table information" />
          <topic href="reference009.htm#CACFHGHE" label="Inheritance information" />
          <topic href="reference010.htm#sthref226" label="Queries" />
        </topic>
        <topic href="ref_persistence_map_view.htm#BABIFBAF" label="JPA Details view (for attributes)">
          <topic href="ref_mapping_general.htm#CACBHFIJ" label="General information" />
          <topic href="reference011.htm#CACBAEBC" label="Join Table Information" />
          <topic href="reference012.htm#CACFCEJC" label="Join Columns Information" />
          <topic href="ref_primary_key.htm#CACFCCAB" label="Primary Key Generation information" />
        </topic>
        <topic href="ref_details_orm.htm#CACGDGHC" label="JPA Details view (for orm.xml)">
          <topic href="reference013.htm#CACCACGH" label="General information" />
          <topic href="reference014.htm#CACEAGBG" label="Persistence Unit information" />
          <topic href="reference015.htm#CIAFGAIJ" label="Generators" />
          <topic href="reference016.htm#CIAIBAAJ" label="Queries" />
          <topic href="reference017.htm#CIADGCID" label="Converters" />
        </topic>
        <topic href="ref_persistence_outline.htm#BABEGGFE" label="JPA Structure view" />
        <topic href="ref_persistence_xmll_editor.htm#CIACCHID" label="persistence.xml Editor">
          <topic href="ref_persistence_general.htm#CIACIFGJ" label="General" />
          <topic href="reference018.htm#CIAFFJIE" label="Connection" />
          <topic href="reference019.htm#CIAJAFEG" label="Customization" />
          <topic href="reference020.htm#CIABEDCH" label="Caching" />
          <topic href="reference021.htm#CIABGHHI" label="Logging" />
          <topic href="reference022.htm#CIAFJCHE" label="Options" />
          <topic href="reference023.htm#CIACCFCB" label="Schema Generation" />
          <topic href="reference024.htm#CIAHJDFF" label="Properties" />
          <topic href="reference025.htm#CIAHCJAH" label="Source" />
        </topic>
      </topic>
      <topic label="Preferences">
        <topic href="ref_project_properties.htm#BABJHBCI" label="Project Properties page - Java Persistence Options" />
      </topic>
      <topic label="Dialogs">
        <topic href="reference028.htm#CACCGEHC" label="Edit Join Columns Dialog" />
        <topic href="ref_select_cascade_dialog.htm#CIAFDGIJ" label="Select Cascade dialog" />
        <topic href="ref_eclipselink_mapping_file.htm#CIAEDEJF" label="New EclipseLink Mapping File dialog" />
        <topic href="ref_add_converter.htm#CIAGCGIJ" label="Add Converter dialog" />
      </topic>
      <topic href="ref_persistence_perspective.htm#BABIFBDB" label="JPA Development perspective" />
      <topic label="Icons and buttons">
        <topic href="reference030.htm#CACGEACG" label="Icons" />
        <topic href="reference031.htm#CACDJCEI" label="Buttons" />
      </topic>
      <topic href="reference032.htm#CACBBDIB" label="Dali Developer Documentation" />
    </topic>
    <topic href="tips_and_tricks.htm" label="Tips and tricks">
      <topic href="whats_new001.htm#CJACEDDE" label="JPA Library Management" />
      <topic href="whats_new002.htm#CJADIFHJ" label="New Generate Entities from Tables Wizard" />
      <topic href="whats_new003.htm#CJABIJEC" label="Conversion of Java Projects to JPA Projects" />
      <topic href="whats_new004.htm#CJACJBDA" label="EclipseLink 1.1 Support" />
      <topic href="whats_new005.htm#sthref286" label="Table-per-Concrete-Class Inheritance" />
    </topic>
    <topic href="legal.htm" label=" Legal">
      <topic href="about.htm#sthref288" label="About this content" />
    </topic>
</toc>
