<?xml version="1.0" encoding="UTF-8"?>
<!--
 Licensed to the Apache Software Foundation (ASF) under one
 or more contributor license agreements.  See the NOTICE file
 distributed with this work for additional information
 regarding copyright ownership.  The ASF licenses this file
 to you under the Apache License, Version 2.0 (the
 "License"); you may not use this file except in compliance
 with the License.  You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing,
 software distributed under the License is distributed on an
 "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
-->
<para>
There are two sets of properties that may be specified: those that
are specific to OpenJPA and those that have been defined by the JPA
specification. In some cases, two properties may be equivalent, but
have different keys. For example, <emphasis>openjpa.LockTimeout
</emphasis> and <emphasis>javax.persistence.lock.timeout</emphasis>
are two different keys for the same property.
</para>
<para>
There are two methods that can be used to retrieve information related to
properties:
<programlisting>
public Map&lt;String,Object&gt; getProperties();
public Set&lt;String&gt; getSupportedProperties();
</programlisting>
	<itemizedlist>
		<listitem>
			<para>
			<methodname>getProperties</methodname> - Provides a list of current
			properties. If a property has more than one key, the key
			that will be returned is the one that was used when the
			property was set. If the property was not explicitly
			set, the key defined by the JPA specification will be returned
			with the default value.
			</para>
		</listitem>
		<listitem>
			<para>
			<methodname>getSupportedProperties</methodname> - Returns a set of
			supported property keys. This includes keys defined by the JPA
			specification as well as keys specific to OpenJPA.
			If a property
			has more than one key, all possible keys will be returned.
			</para>
		</listitem>
	</itemizedlist>
</para>
<note>
	<para>
		The <methodname>getSupportedProperties</methodname> method is an OpenJPA
		extension to the JPA specification.
	</para>
</note>
