<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<title>LifeCycleManager</title>
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="LifeCycleManager";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":6,"i1":6,"i2":6,"i3":6,"i4":6,"i5":6,"i6":6,"i7":6,"i8":6,"i9":6,"i10":6,"i11":6,"i12":6,"i13":6,"i14":6,"i15":6,"i16":6,"i17":6,"i18":6,"i19":6,"i20":6,"i21":6,"i22":6,"i23":6,"i24":6,"i25":6,"i26":6,"i27":6,"i28":6,"i29":6,"i30":6,"i31":6,"i32":6,"i33":6,"i34":6,"i35":6,"i36":6,"i37":6,"i38":6,"i39":6,"i40":6,"i41":6,"i42":6,"i43":6};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],4:["t3","Abstract Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../index-all.html">Index</a></li>
<li><a href="../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../javax/xml/registry/JAXRResponse.html" title="interface in javax.xml.registry"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../javax/xml/registry/Query.html" title="interface in javax.xml.registry"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?javax/xml/registry/LifeCycleManager.html" target="_top">Frames</a></li>
<li><a href="LifeCycleManager.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">javax.xml.registry</div>
<h2 title="Interface LifeCycleManager" class="title">Interface LifeCycleManager</h2>
</div>
<div class="contentContainer">
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Known Subinterfaces:</dt>
<dd><a href="../../../javax/xml/registry/BusinessLifeCycleManager.html" title="interface in javax.xml.registry">BusinessLifeCycleManager</a></dd>
</dl>
<hr>
<br>
<pre>public interface <span class="typeNameLabel">LifeCycleManager</span></pre>
<div class="block">The LifeCycleManager interface is the main interface in the API for managing life cycle
 operations on objects defined by the information model.
 <p>
 The factory methods of this interface must throw an UnsupportedCapabilityException if the client attempts to create an instance of an infomodel interface that is not supported by the capability level of the JAXR provider.</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#ASSOCIATION">ASSOCIATION</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Association interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#AUDITABLE_EVENT">AUDITABLE_EVENT</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.AuditableEvent interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#CLASSIFICATION">CLASSIFICATION</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Classification interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#CLASSIFICATION_SCHEME">CLASSIFICATION_SCHEME</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.ClassificationScheme interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#CONCEPT">CONCEPT</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Concept interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#EMAIL_ADDRESS">EMAIL_ADDRESS</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.EmailAddress interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#EXTERNAL_IDENTIFIER">EXTERNAL_IDENTIFIER</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.ExternalIdentifier interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#EXTERNAL_LINK">EXTERNAL_LINK</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.ExternalLink interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#EXTRINSIC_OBJECT">EXTRINSIC_OBJECT</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.ExternalLink interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#INTERNATIONAL_STRING">INTERNATIONAL_STRING</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.InternationalString interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#KEY">KEY</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Key interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#LOCALIZED_STRING">LOCALIZED_STRING</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.LocalizedString interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#ORGANIZATION">ORGANIZATION</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Organization interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#PERSON_NAME">PERSON_NAME</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.PersonName interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#POSTAL_ADDRESS">POSTAL_ADDRESS</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.PostalAddress interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#REGISTRY_ENTRY">REGISTRY_ENTRY</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.RegistryEntry interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#REGISTRY_PACKAGE">REGISTRY_PACKAGE</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.RegistryPackage interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#SERVICE">SERVICE</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Service interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#SERVICE_BINDING">SERVICE_BINDING</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.ServiceBinding interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#SLOT">SLOT</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Slot interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#SPECIFICATION_LINK">SPECIFICATION_LINK</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.SpecificationLink interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#TELEPHONE_NUMBER">TELEPHONE_NUMBER</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.TelephoneNumber interface.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#USER">USER</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.User interface.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#VERSIONABLE">VERSIONABLE</a></span></code>
<div class="block">Constant representing the javax.xml.registry.infomodel.Versionable interface.</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t3" class="tableTab"><span><a href="javascript:show(4);">Abstract Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Association.html" title="interface in javax.xml.registry.infomodel">Association</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createAssociation-javax.xml.registry.infomodel.RegistryObject-javax.xml.registry.infomodel.Concept-">createAssociation</a></span>(<a href="../../../javax/xml/registry/infomodel/RegistryObject.html" title="interface in javax.xml.registry.infomodel">RegistryObject</a>&nbsp;targetObject,
                 <a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;associationType)</code>
<div class="block">Creates an Association instance using the specified
 parameters.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Classification.html" title="interface in javax.xml.registry.infomodel">Classification</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createClassification-javax.xml.registry.infomodel.ClassificationScheme-javax.xml.registry.infomodel.InternationalString-java.lang.String-">createClassification</a></span>(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;scheme,
                    <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
                    java.lang.String&nbsp;value)</code>
<div class="block">Creates a Classification instance for an external
 Classification using the specified InternationalString name and String value that identify
 a taxonomy element within the specified ClassificationScheme.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Classification.html" title="interface in javax.xml.registry.infomodel">Classification</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createClassification-javax.xml.registry.infomodel.ClassificationScheme-java.lang.String-java.lang.String-">createClassification</a></span>(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;scheme,
                    java.lang.String&nbsp;name,
                    java.lang.String&nbsp;value)</code>
<div class="block">Creates a Classification instance for an external
 Classification using the specified String name and String value that identify
 a taxonomy element within the specified ClassificationScheme.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Classification.html" title="interface in javax.xml.registry.infomodel">Classification</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createClassification-javax.xml.registry.infomodel.Concept-">createClassification</a></span>(<a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;concept)</code>
<div class="block">Creates a Classification instance for an internal
 Classification using the specified Concept that identifies
 a taxonomy element within an internal ClassificationScheme.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createClassificationScheme-javax.xml.registry.infomodel.Concept-">createClassificationScheme</a></span>(<a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;concept)</code>
<div class="block">Creates a ClassificationScheme from a Concept that has no
 ClassificationScheme or parent Concept.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createClassificationScheme-javax.xml.registry.infomodel.InternationalString-javax.xml.registry.infomodel.InternationalString-">createClassificationScheme</a></span>(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
                          <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;description)</code>
<div class="block">Creates a ClassificationScheme given the specified
 InternationalString parameters.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createClassificationScheme-java.lang.String-java.lang.String-">createClassificationScheme</a></span>(java.lang.String&nbsp;name,
                          java.lang.String&nbsp;description)</code>
<div class="block">Creates a ClassificationScheme given the specified String parameters.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createConcept-javax.xml.registry.infomodel.RegistryObject-javax.xml.registry.infomodel.InternationalString-java.lang.String-">createConcept</a></span>(<a href="../../../javax/xml/registry/infomodel/RegistryObject.html" title="interface in javax.xml.registry.infomodel">RegistryObject</a>&nbsp;parent,
             <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
             java.lang.String&nbsp;value)</code>
<div class="block">Creates a Concept instance using the specified
 parameters, where the name is an InternationalString.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createConcept-javax.xml.registry.infomodel.RegistryObject-java.lang.String-java.lang.String-">createConcept</a></span>(<a href="../../../javax/xml/registry/infomodel/RegistryObject.html" title="interface in javax.xml.registry.infomodel">RegistryObject</a>&nbsp;parent,
             java.lang.String&nbsp;name,
             java.lang.String&nbsp;value)</code>
<div class="block">Creates a Concept instance using the specified
 parameters, where the name is a String.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/EmailAddress.html" title="interface in javax.xml.registry.infomodel">EmailAddress</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createEmailAddress-java.lang.String-">createEmailAddress</a></span>(java.lang.String&nbsp;address)</code>
<div class="block">Creates an EmailAddress instance using an address as the
 parameter.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/EmailAddress.html" title="interface in javax.xml.registry.infomodel">EmailAddress</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createEmailAddress-java.lang.String-java.lang.String-">createEmailAddress</a></span>(java.lang.String&nbsp;address,
                  java.lang.String&nbsp;type)</code>
<div class="block">Creates an EmailAddress instance using both an address and a type as
 parameters.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ExternalIdentifier.html" title="interface in javax.xml.registry.infomodel">ExternalIdentifier</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createExternalIdentifier-javax.xml.registry.infomodel.ClassificationScheme-javax.xml.registry.infomodel.InternationalString-java.lang.String-">createExternalIdentifier</a></span>(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;identificationScheme,
                        <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
                        java.lang.String&nbsp;value)</code>
<div class="block">Creates an ExternalIdentifier instance using the specified
 parameters, where the name is an InternationalString.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ExternalIdentifier.html" title="interface in javax.xml.registry.infomodel">ExternalIdentifier</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createExternalIdentifier-javax.xml.registry.infomodel.ClassificationScheme-java.lang.String-java.lang.String-">createExternalIdentifier</a></span>(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;identificationScheme,
                        java.lang.String&nbsp;name,
                        java.lang.String&nbsp;value)</code>
<div class="block">Creates an ExternalIdentifier instance using the specified
 parameters, where the name is a String.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ExternalLink.html" title="interface in javax.xml.registry.infomodel">ExternalLink</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createExternalLink-java.lang.String-javax.xml.registry.infomodel.InternationalString-">createExternalLink</a></span>(java.lang.String&nbsp;externalURI,
                  <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;description)</code>
<div class="block">Creates an ExternalLink instance using the specified
 parameters, where the description is an InternationalString.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ExternalLink.html" title="interface in javax.xml.registry.infomodel">ExternalLink</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createExternalLink-java.lang.String-java.lang.String-">createExternalLink</a></span>(java.lang.String&nbsp;externalURI,
                  java.lang.String&nbsp;description)</code>
<div class="block">Creates an ExternalLink instance using the specified
 parameters, where the description is a String.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ExtrinsicObject.html" title="interface in javax.xml.registry.infomodel">ExtrinsicObject</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createExtrinsicObject-javax.activation.DataHandler-">createExtrinsicObject</a></span>(javax.activation.DataHandler&nbsp;repositoryItem)</code>
<div class="block">Creates an ExtrinsicObject instance using the specified
 parameters.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createInternationalString--">createInternationalString</a></span>()</code>
<div class="block">Creates an empty InternationalString instance.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createInternationalString-java.util.Locale-java.lang.String-">createInternationalString</a></span>(java.util.Locale&nbsp;l,
                         java.lang.String&nbsp;s)</code>
<div class="block">Creates an InternationalString instance using the specified
 Locale and String parameters.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createInternationalString-java.lang.String-">createInternationalString</a></span>(java.lang.String&nbsp;s)</code>
<div class="block">Creates an InternationalString instance using a String
 parameter and the default Locale.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Key.html" title="interface in javax.xml.registry.infomodel">Key</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createKey-java.lang.String-">createKey</a></span>(java.lang.String&nbsp;id)</code>
<div class="block">Creates a Key instance from an ID.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/LocalizedString.html" title="interface in javax.xml.registry.infomodel">LocalizedString</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createLocalizedString-java.util.Locale-java.lang.String-">createLocalizedString</a></span>(java.util.Locale&nbsp;l,
                     java.lang.String&nbsp;s)</code>
<div class="block">Creates a LocalizedString instance using the specified
 Locale and String parameters.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/LocalizedString.html" title="interface in javax.xml.registry.infomodel">LocalizedString</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createLocalizedString-java.util.Locale-java.lang.String-java.lang.String-">createLocalizedString</a></span>(java.util.Locale&nbsp;l,
                     java.lang.String&nbsp;s,
                     java.lang.String&nbsp;charSetName)</code>
<div class="block">Creates a LocalizedString instance using the specified
 Locale, String, and character set parameters.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code>java.lang.Object</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createObject-java.lang.String-">createObject</a></span>(java.lang.String&nbsp;interfaceName)</code>
<div class="block">Creates instances of information model
 interfaces (factory method).</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Organization.html" title="interface in javax.xml.registry.infomodel">Organization</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createOrganization-javax.xml.registry.infomodel.InternationalString-">createOrganization</a></span>(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name)</code>
<div class="block">Creates an Organization instance using the specified
 name, where the name is an InternationalString.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Organization.html" title="interface in javax.xml.registry.infomodel">Organization</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createOrganization-java.lang.String-">createOrganization</a></span>(java.lang.String&nbsp;name)</code>
<div class="block">Creates an Organization instance using the specified
 name, where the name is a String.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/PersonName.html" title="interface in javax.xml.registry.infomodel">PersonName</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createPersonName-java.lang.String-">createPersonName</a></span>(java.lang.String&nbsp;fullName)</code>
<div class="block">Creates a PersonName instance using the specified
 full name.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/PersonName.html" title="interface in javax.xml.registry.infomodel">PersonName</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createPersonName-java.lang.String-java.lang.String-java.lang.String-">createPersonName</a></span>(java.lang.String&nbsp;firstName,
                java.lang.String&nbsp;middleName,
                java.lang.String&nbsp;lastName)</code>
<div class="block">Creates a PersonName instance using the specified
 first, middle, and last names.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/PostalAddress.html" title="interface in javax.xml.registry.infomodel">PostalAddress</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createPostalAddress-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">createPostalAddress</a></span>(java.lang.String&nbsp;streetNumber,
                   java.lang.String&nbsp;street,
                   java.lang.String&nbsp;city,
                   java.lang.String&nbsp;stateOrProvince,
                   java.lang.String&nbsp;country,
                   java.lang.String&nbsp;postalCode,
                   java.lang.String&nbsp;type)</code>
<div class="block">Creates a PostalAddress instance using the specified
 parameters.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/RegistryPackage.html" title="interface in javax.xml.registry.infomodel">RegistryPackage</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createRegistryPackage-javax.xml.registry.infomodel.InternationalString-">createRegistryPackage</a></span>(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name)</code>
<div class="block">Creates a RegistryPackage instance using the specified
 name, where the name is an InternationalString.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/RegistryPackage.html" title="interface in javax.xml.registry.infomodel">RegistryPackage</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createRegistryPackage-java.lang.String-">createRegistryPackage</a></span>(java.lang.String&nbsp;name)</code>
<div class="block">Creates a RegistryPackage instance using the specified
 name, where the name is a String.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Service.html" title="interface in javax.xml.registry.infomodel">Service</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createService-javax.xml.registry.infomodel.InternationalString-">createService</a></span>(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name)</code>
<div class="block">Creates a Service instance using the specified
 name, where the name is an InternationalString.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Service.html" title="interface in javax.xml.registry.infomodel">Service</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createService-java.lang.String-">createService</a></span>(java.lang.String&nbsp;name)</code>
<div class="block">Creates a Service instance using the specified
 name, where the name is a String.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/ServiceBinding.html" title="interface in javax.xml.registry.infomodel">ServiceBinding</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createServiceBinding--">createServiceBinding</a></span>()</code>
<div class="block">Creates an empty ServiceBinding instance.</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Slot.html" title="interface in javax.xml.registry.infomodel">Slot</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createSlot-java.lang.String-java.util.Collection-java.lang.String-">createSlot</a></span>(java.lang.String&nbsp;name,
          java.util.Collection&nbsp;values,
          java.lang.String&nbsp;slotType)</code>
<div class="block">Creates a Slot instance using the specified
 parameters, where the value is a Collection of Strings.</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/Slot.html" title="interface in javax.xml.registry.infomodel">Slot</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createSlot-java.lang.String-java.lang.String-java.lang.String-">createSlot</a></span>(java.lang.String&nbsp;name,
          java.lang.String&nbsp;value,
          java.lang.String&nbsp;slotType)</code>
<div class="block">Creates a Slot instance using the specified
 parameters, where the value is a String.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/SpecificationLink.html" title="interface in javax.xml.registry.infomodel">SpecificationLink</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createSpecificationLink--">createSpecificationLink</a></span>()</code>
<div class="block">Creates an empty SpecificationLink instance.</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/TelephoneNumber.html" title="interface in javax.xml.registry.infomodel">TelephoneNumber</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createTelephoneNumber--">createTelephoneNumber</a></span>()</code>
<div class="block">Creates an empty TelephoneNumber instance.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/infomodel/User.html" title="interface in javax.xml.registry.infomodel">User</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#createUser--">createUser</a></span>()</code>
<div class="block">Creates an empty User instance.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#deleteObjects-java.util.Collection-">deleteObjects</a></span>(java.util.Collection&nbsp;keys)</code>
<div class="block">Deletes one or more previously submitted objects from the registry
 using the object keys.</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#deleteObjects-java.util.Collection-java.lang.String-">deleteObjects</a></span>(java.util.Collection&nbsp;keys,
             java.lang.String&nbsp;objectType)</code>
<div class="block">Deletes one or more previously submitted objects from the registry
 using the object keys and a specified objectType attribute.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#deprecateObjects-java.util.Collection-">deprecateObjects</a></span>(java.util.Collection&nbsp;keys)</code>
<div class="block">Deprecates one or more previously submitted objects.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/RegistryService.html" title="interface in javax.xml.registry">RegistryService</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#getRegistryService--">getRegistryService</a></span>()</code>
<div class="block">Returns the parent RegistryService that created this object.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#saveObjects-java.util.Collection-">saveObjects</a></span>(java.util.Collection&nbsp;objects)</code>
<div class="block">Saves one or more Objects to the registry.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/xml/registry/LifeCycleManager.html#unDeprecateObjects-java.util.Collection-">unDeprecateObjects</a></span>(java.util.Collection&nbsp;keys)</code>
<div class="block">Undeprecates one or more previously deprecated objects.</div>
</td>
</tr>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="ASSOCIATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ASSOCIATION</h4>
<pre>static final&nbsp;java.lang.String ASSOCIATION</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Association interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.ASSOCIATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="AUDITABLE_EVENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>AUDITABLE_EVENT</h4>
<pre>static final&nbsp;java.lang.String AUDITABLE_EVENT</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.AuditableEvent interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.AUDITABLE_EVENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CLASSIFICATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CLASSIFICATION</h4>
<pre>static final&nbsp;java.lang.String CLASSIFICATION</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Classification interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.CLASSIFICATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CLASSIFICATION_SCHEME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CLASSIFICATION_SCHEME</h4>
<pre>static final&nbsp;java.lang.String CLASSIFICATION_SCHEME</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.ClassificationScheme interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.CLASSIFICATION_SCHEME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CONCEPT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CONCEPT</h4>
<pre>static final&nbsp;java.lang.String CONCEPT</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Concept interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.CONCEPT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EMAIL_ADDRESS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>EMAIL_ADDRESS</h4>
<pre>static final&nbsp;java.lang.String EMAIL_ADDRESS</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.EmailAddress interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.EMAIL_ADDRESS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EXTERNAL_IDENTIFIER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>EXTERNAL_IDENTIFIER</h4>
<pre>static final&nbsp;java.lang.String EXTERNAL_IDENTIFIER</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.ExternalIdentifier interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.EXTERNAL_IDENTIFIER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EXTERNAL_LINK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>EXTERNAL_LINK</h4>
<pre>static final&nbsp;java.lang.String EXTERNAL_LINK</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.ExternalLink interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.EXTERNAL_LINK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EXTRINSIC_OBJECT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>EXTRINSIC_OBJECT</h4>
<pre>static final&nbsp;java.lang.String EXTRINSIC_OBJECT</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.ExternalLink interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.EXTRINSIC_OBJECT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="INTERNATIONAL_STRING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>INTERNATIONAL_STRING</h4>
<pre>static final&nbsp;java.lang.String INTERNATIONAL_STRING</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.InternationalString interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.INTERNATIONAL_STRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="KEY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>KEY</h4>
<pre>static final&nbsp;java.lang.String KEY</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Key interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.KEY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOCALIZED_STRING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOCALIZED_STRING</h4>
<pre>static final&nbsp;java.lang.String LOCALIZED_STRING</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.LocalizedString interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.LOCALIZED_STRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="ORGANIZATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ORGANIZATION</h4>
<pre>static final&nbsp;java.lang.String ORGANIZATION</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Organization interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.ORGANIZATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PERSON_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PERSON_NAME</h4>
<pre>static final&nbsp;java.lang.String PERSON_NAME</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.PersonName interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.PERSON_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="POSTAL_ADDRESS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>POSTAL_ADDRESS</h4>
<pre>static final&nbsp;java.lang.String POSTAL_ADDRESS</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.PostalAddress interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.POSTAL_ADDRESS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="REGISTRY_ENTRY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>REGISTRY_ENTRY</h4>
<pre>static final&nbsp;java.lang.String REGISTRY_ENTRY</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.RegistryEntry interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.REGISTRY_ENTRY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="REGISTRY_PACKAGE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>REGISTRY_PACKAGE</h4>
<pre>static final&nbsp;java.lang.String REGISTRY_PACKAGE</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.RegistryPackage interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.REGISTRY_PACKAGE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SERVICE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SERVICE</h4>
<pre>static final&nbsp;java.lang.String SERVICE</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Service interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.SERVICE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SERVICE_BINDING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SERVICE_BINDING</h4>
<pre>static final&nbsp;java.lang.String SERVICE_BINDING</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.ServiceBinding interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.SERVICE_BINDING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SLOT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SLOT</h4>
<pre>static final&nbsp;java.lang.String SLOT</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Slot interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.SLOT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SPECIFICATION_LINK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SPECIFICATION_LINK</h4>
<pre>static final&nbsp;java.lang.String SPECIFICATION_LINK</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.SpecificationLink interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.SPECIFICATION_LINK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TELEPHONE_NUMBER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TELEPHONE_NUMBER</h4>
<pre>static final&nbsp;java.lang.String TELEPHONE_NUMBER</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.TelephoneNumber interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.TELEPHONE_NUMBER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="USER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>USER</h4>
<pre>static final&nbsp;java.lang.String USER</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.User interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.USER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="VERSIONABLE">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>VERSIONABLE</h4>
<pre>static final&nbsp;java.lang.String VERSIONABLE</pre>
<div class="block">Constant representing the javax.xml.registry.infomodel.Versionable interface.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>LifeCycleManager.createObject</code>, 
<a href="../../../constant-values.html#javax.xml.registry.LifeCycleManager.VERSIONABLE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="createObject-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createObject</h4>
<pre>java.lang.Object&nbsp;createObject(java.lang.String&nbsp;interfaceName)
                       throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a>,
                              <a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a>,
                              <a href="../../../javax/xml/registry/UnsupportedCapabilityException.html" title="class in javax.xml.registry">UnsupportedCapabilityException</a></pre>
<div class="block">Creates instances of information model
 interfaces (factory method). To create an Organization, use this
 method as follows:
 <pre>
 Organization org = (Organization)
    lifeCycleMgr.createObject(LifeCycleManager.ORGANIZATION);
 </pre>
 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>interfaceName</code> - the unqualified name of an interface in the javax.xml.registry.infomodel package</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>an Object that can then be cast to an instance of the interface</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
<dd><code><a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></code> - if the interface is not an interface in
 the javax.xml.registry.infomodel package</dd>
<dd><code><a href="../../../javax/xml/registry/UnsupportedCapabilityException.html" title="class in javax.xml.registry">UnsupportedCapabilityException</a></code> - if the client attempts to create an instance of an infomodel interface that is not supported by the capability level of the JAXR provider</dd>
</dl>
</li>
</ul>
<a name="createAssociation-javax.xml.registry.infomodel.RegistryObject-javax.xml.registry.infomodel.Concept-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createAssociation</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Association.html" title="interface in javax.xml.registry.infomodel">Association</a>&nbsp;createAssociation(<a href="../../../javax/xml/registry/infomodel/RegistryObject.html" title="interface in javax.xml.registry.infomodel">RegistryObject</a>&nbsp;targetObject,
                              <a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;associationType)
                       throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an Association instance using the specified
 parameters. The sourceObject is left null and will be set
 when the Association is added to a RegistryObject.
 <p>
 Note that for a UDDI provider an Association may only be created
 between Organizations.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>targetObject</code> - the target RegistryObject for the association</dd>
<dd><code>associationType</code> - the association type for the Association</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Association instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createClassification-javax.xml.registry.infomodel.ClassificationScheme-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClassification</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Classification.html" title="interface in javax.xml.registry.infomodel">Classification</a>&nbsp;createClassification(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;scheme,
                                    java.lang.String&nbsp;name,
                                    java.lang.String&nbsp;value)
                             throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Classification instance for an external
 Classification using the specified String name and String value that identify
 a taxonomy element within the specified ClassificationScheme.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>scheme</code> - the ClassificationScheme to be used</dd>
<dd><code>name</code> - the name of the taxonomy element (a String)</dd>
<dd><code>value</code> - the value of the taxonomy element</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Classification instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createClassification-javax.xml.registry.infomodel.ClassificationScheme-javax.xml.registry.infomodel.InternationalString-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClassification</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Classification.html" title="interface in javax.xml.registry.infomodel">Classification</a>&nbsp;createClassification(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;scheme,
                                    <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
                                    java.lang.String&nbsp;value)
                             throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Classification instance for an external
 Classification using the specified InternationalString name and String value that identify
 a taxonomy element within the specified ClassificationScheme.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>scheme</code> - the ClassificationScheme to be used</dd>
<dd><code>name</code> - the name of the taxonomy element (an InternationalString)</dd>
<dd><code>value</code> - the value of the taxonomy element</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Classification instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createClassification-javax.xml.registry.infomodel.Concept-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClassification</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Classification.html" title="interface in javax.xml.registry.infomodel">Classification</a>&nbsp;createClassification(<a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;concept)
                             throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a>,
                                    <a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></pre>
<div class="block">Creates a Classification instance for an internal
 Classification using the specified Concept that identifies
 a taxonomy element within an internal ClassificationScheme.
 <p>

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>concept</code> - the Concept that identifies the taxonomy element</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Classification instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
<dd><code><a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></code> - if the Concept is not under
 a ClassificationScheme</dd>
</dl>
</li>
</ul>
<a name="createClassificationScheme-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClassificationScheme</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;createClassificationScheme(java.lang.String&nbsp;name,
                                                java.lang.String&nbsp;description)
                                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a>,
                                                <a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></pre>
<div class="block">Creates a ClassificationScheme given the specified String parameters.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the ClassificationScheme (a String)</dd>
<dd><code>description</code> - a description of the ClassificationScheme (a String)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ClassificationScheme instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
<dd><code><a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></code></dd>
</dl>
</li>
</ul>
<a name="createClassificationScheme-javax.xml.registry.infomodel.InternationalString-javax.xml.registry.infomodel.InternationalString-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClassificationScheme</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;createClassificationScheme(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
                                                <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;description)
                                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a>,
                                                <a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></pre>
<div class="block">Creates a ClassificationScheme given the specified
 InternationalString parameters.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the ClassificationScheme (an InternationalString)</dd>
<dd><code>description</code> - a description of the ClassificationScheme (an InternationalString)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ClassificationScheme instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
<dd><code><a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></code></dd>
</dl>
</li>
</ul>
<a name="createClassificationScheme-javax.xml.registry.infomodel.Concept-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClassificationScheme</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;createClassificationScheme(<a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;concept)
                                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a>,
                                                <a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></pre>
<div class="block">Creates a ClassificationScheme from a Concept that has no
 ClassificationScheme or parent Concept.
 <p>
 This method is a special-case method to do a type-safe conversion
 from Concept to ClassificationScheme.
 <p>
 This method is
 provided to allow for Concepts returned by the BusinessQueryManager
 findConcepts call to be safely cast to ClassificationScheme. It
 is up to the programmer to make sure that the Concept is indeed
 semantically a ClassificationScheme.
 <p>
 This method is necessary because in the UDDI specification a tModel may serve
 multiple purposes, and there is no way to know when a tModel
 maps to a Concept and when it maps to a ClassificationScheme.
 The UDDI specification leaves the determination to the programmer, and consequently so does this
 method.
 <p>

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>concept</code> - the Concept to be used</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ClassificationScheme instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
<dd><code><a href="../../../javax/xml/registry/InvalidRequestException.html" title="class in javax.xml.registry">InvalidRequestException</a></code> - if the Concept has a parent Concept
 or is under a ClassificationScheme</dd>
</dl>
</li>
</ul>
<a name="createConcept-javax.xml.registry.infomodel.RegistryObject-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createConcept</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;createConcept(<a href="../../../javax/xml/registry/infomodel/RegistryObject.html" title="interface in javax.xml.registry.infomodel">RegistryObject</a>&nbsp;parent,
                      java.lang.String&nbsp;name,
                      java.lang.String&nbsp;value)
               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Concept instance using the specified
 parameters, where the name is a String.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>parent</code> - a reference either to a parent ClassificationScheme or to a Concept</dd>
<dd><code>name</code> - the name of the concept (a String)</dd>
<dd><code>value</code> - the value of the concept</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Concept instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createConcept-javax.xml.registry.infomodel.RegistryObject-javax.xml.registry.infomodel.InternationalString-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createConcept</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Concept.html" title="interface in javax.xml.registry.infomodel">Concept</a>&nbsp;createConcept(<a href="../../../javax/xml/registry/infomodel/RegistryObject.html" title="interface in javax.xml.registry.infomodel">RegistryObject</a>&nbsp;parent,
                      <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
                      java.lang.String&nbsp;value)
               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Concept instance using the specified
 parameters, where the name is an InternationalString.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>parent</code> - a reference either to a parent ClassificationScheme or to a Concept</dd>
<dd><code>name</code> - the name of the concept (an InternationalString)</dd>
<dd><code>value</code> - the value of the concept</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Concept instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createEmailAddress-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEmailAddress</h4>
<pre><a href="../../../javax/xml/registry/infomodel/EmailAddress.html" title="interface in javax.xml.registry.infomodel">EmailAddress</a>&nbsp;createEmailAddress(java.lang.String&nbsp;address)
                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an EmailAddress instance using an address as the
 parameter.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>address</code> - the email address</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the EmailAddress instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createEmailAddress-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEmailAddress</h4>
<pre><a href="../../../javax/xml/registry/infomodel/EmailAddress.html" title="interface in javax.xml.registry.infomodel">EmailAddress</a>&nbsp;createEmailAddress(java.lang.String&nbsp;address,
                                java.lang.String&nbsp;type)
                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an EmailAddress instance using both an address and a type as
 parameters.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>address</code> - the email address</dd>
<dd><code>type</code> - the type of the address</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the EmailAddress instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createExternalIdentifier-javax.xml.registry.infomodel.ClassificationScheme-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createExternalIdentifier</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ExternalIdentifier.html" title="interface in javax.xml.registry.infomodel">ExternalIdentifier</a>&nbsp;createExternalIdentifier(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;identificationScheme,
                                            java.lang.String&nbsp;name,
                                            java.lang.String&nbsp;value)
                                     throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an ExternalIdentifier instance using the specified
 parameters, where the name is a String.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>identificationScheme</code> - the ClassificationScheme used</dd>
<dd><code>name</code> - the name of the external identifier (a String)</dd>
<dd><code>value</code> - the value of the external identifier</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ExternalIdentifier instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createExternalIdentifier-javax.xml.registry.infomodel.ClassificationScheme-javax.xml.registry.infomodel.InternationalString-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createExternalIdentifier</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ExternalIdentifier.html" title="interface in javax.xml.registry.infomodel">ExternalIdentifier</a>&nbsp;createExternalIdentifier(<a href="../../../javax/xml/registry/infomodel/ClassificationScheme.html" title="interface in javax.xml.registry.infomodel">ClassificationScheme</a>&nbsp;identificationScheme,
                                            <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name,
                                            java.lang.String&nbsp;value)
                                     throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an ExternalIdentifier instance using the specified
 parameters, where the name is an InternationalString.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>identificationScheme</code> - the ClassificationScheme used</dd>
<dd><code>name</code> - the name of the external identifier (an InternationalString)</dd>
<dd><code>value</code> - the value of the external identifier</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ExternalIdentifier instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createExternalLink-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createExternalLink</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ExternalLink.html" title="interface in javax.xml.registry.infomodel">ExternalLink</a>&nbsp;createExternalLink(java.lang.String&nbsp;externalURI,
                                java.lang.String&nbsp;description)
                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an ExternalLink instance using the specified
 parameters, where the description is a String.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>externalURI</code> - the external URI</dd>
<dd><code>description</code> - a description of the link (a String)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ExternalLink instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createExternalLink-java.lang.String-javax.xml.registry.infomodel.InternationalString-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createExternalLink</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ExternalLink.html" title="interface in javax.xml.registry.infomodel">ExternalLink</a>&nbsp;createExternalLink(java.lang.String&nbsp;externalURI,
                                <a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;description)
                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an ExternalLink instance using the specified
 parameters, where the description is an InternationalString.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>externalURI</code> - the external URI</dd>
<dd><code>description</code> - a description of the link (an InternationalString)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ExternalLink instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createExtrinsicObject-javax.activation.DataHandler-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createExtrinsicObject</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ExtrinsicObject.html" title="interface in javax.xml.registry.infomodel">ExtrinsicObject</a>&nbsp;createExtrinsicObject(javax.activation.DataHandler&nbsp;repositoryItem)
                               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an ExtrinsicObject instance using the specified
 parameters.


 <p><DL><DT><B>Capability Level: 1 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>repositoryItem</code> - the DataHandler for the repository item. Must not be null.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ExtrinsicObject instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createInternationalString--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createInternationalString</h4>
<pre><a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;createInternationalString()
                                       throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an empty InternationalString instance.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the InternationalString instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createInternationalString-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createInternationalString</h4>
<pre><a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;createInternationalString(java.lang.String&nbsp;s)
                                       throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an InternationalString instance using a String
 parameter and the default Locale.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>s</code> - the String from which to create the InternationalString</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the InternationalString instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createInternationalString-java.util.Locale-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createInternationalString</h4>
<pre><a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;createInternationalString(java.util.Locale&nbsp;l,
                                              java.lang.String&nbsp;s)
                                       throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an InternationalString instance using the specified
 Locale and String parameters.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>l</code> - the Locale in which to create the InternationalString</dd>
<dd><code>s</code> - the String from which to create the InternationalString</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the InternationalString instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createKey-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createKey</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Key.html" title="interface in javax.xml.registry.infomodel">Key</a>&nbsp;createKey(java.lang.String&nbsp;id)
       throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Key instance from an ID.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>id</code> - the ID string from which to create the Key</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Key instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createLocalizedString-java.util.Locale-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createLocalizedString</h4>
<pre><a href="../../../javax/xml/registry/infomodel/LocalizedString.html" title="interface in javax.xml.registry.infomodel">LocalizedString</a>&nbsp;createLocalizedString(java.util.Locale&nbsp;l,
                                      java.lang.String&nbsp;s)
                               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a LocalizedString instance using the specified
 Locale and String parameters.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>l</code> - the Locale in which to create the LocalizedString</dd>
<dd><code>s</code> - the String from which to create the LocalizedString</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the LocalizedString instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createLocalizedString-java.util.Locale-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createLocalizedString</h4>
<pre><a href="../../../javax/xml/registry/infomodel/LocalizedString.html" title="interface in javax.xml.registry.infomodel">LocalizedString</a>&nbsp;createLocalizedString(java.util.Locale&nbsp;l,
                                      java.lang.String&nbsp;s,
                                      java.lang.String&nbsp;charSetName)
                               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a LocalizedString instance using the specified
 Locale, String, and character set parameters.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>l</code> - the Locale in which to create the LocalizedString</dd>
<dd><code>s</code> - the String from which to create the LocalizedString</dd>
<dd><code>charSetName</code> - the name of the character set to use</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the LocalizedString instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createOrganization-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createOrganization</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Organization.html" title="interface in javax.xml.registry.infomodel">Organization</a>&nbsp;createOrganization(java.lang.String&nbsp;name)
                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an Organization instance using the specified
 name, where the name is a String.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the Organization</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Organization instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createOrganization-javax.xml.registry.infomodel.InternationalString-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createOrganization</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Organization.html" title="interface in javax.xml.registry.infomodel">Organization</a>&nbsp;createOrganization(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name)
                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an Organization instance using the specified
 name, where the name is an InternationalString.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the Organization</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Organization instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createPersonName-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createPersonName</h4>
<pre><a href="../../../javax/xml/registry/infomodel/PersonName.html" title="interface in javax.xml.registry.infomodel">PersonName</a>&nbsp;createPersonName(java.lang.String&nbsp;firstName,
                            java.lang.String&nbsp;middleName,
                            java.lang.String&nbsp;lastName)
                     throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a PersonName instance using the specified
 first, middle, and last names.

 <p><DL><DT><B>Capability Level: 1 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>firstName</code> - the person's first name</dd>
<dd><code>middleName</code> - the person's middle name</dd>
<dd><code>lastName</code> - the person's last name</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the PersonName instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createPersonName-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createPersonName</h4>
<pre><a href="../../../javax/xml/registry/infomodel/PersonName.html" title="interface in javax.xml.registry.infomodel">PersonName</a>&nbsp;createPersonName(java.lang.String&nbsp;fullName)
                     throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a PersonName instance using the specified
 full name.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>fullName</code> - the person's full name</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the PersonName instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createPostalAddress-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createPostalAddress</h4>
<pre><a href="../../../javax/xml/registry/infomodel/PostalAddress.html" title="interface in javax.xml.registry.infomodel">PostalAddress</a>&nbsp;createPostalAddress(java.lang.String&nbsp;streetNumber,
                                  java.lang.String&nbsp;street,
                                  java.lang.String&nbsp;city,
                                  java.lang.String&nbsp;stateOrProvince,
                                  java.lang.String&nbsp;country,
                                  java.lang.String&nbsp;postalCode,
                                  java.lang.String&nbsp;type)
                           throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a PostalAddress instance using the specified
 parameters.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>streetNumber</code> - the street number</dd>
<dd><code>street</code> - the street name</dd>
<dd><code>city</code> - the city name</dd>
<dd><code>stateOrProvince</code> - the state or province name</dd>
<dd><code>country</code> - the country name</dd>
<dd><code>postalCode</code> - the postal code (such as a US ZIP code)</dd>
<dd><code>type</code> - the type of the address</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the PostalAddress instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createRegistryPackage-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createRegistryPackage</h4>
<pre><a href="../../../javax/xml/registry/infomodel/RegistryPackage.html" title="interface in javax.xml.registry.infomodel">RegistryPackage</a>&nbsp;createRegistryPackage(java.lang.String&nbsp;name)
                               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a RegistryPackage instance using the specified
 name, where the name is a String.

 <p><DL><DT><B>Capability Level: 1 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the registry package (a String)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the RegistryPackage instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createRegistryPackage-javax.xml.registry.infomodel.InternationalString-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createRegistryPackage</h4>
<pre><a href="../../../javax/xml/registry/infomodel/RegistryPackage.html" title="interface in javax.xml.registry.infomodel">RegistryPackage</a>&nbsp;createRegistryPackage(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name)
                               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a RegistryPackage instance using the specified
 name, where the name is an InternationalString.

 <p><DL><DT><B>Capability Level: 1 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the registry package (an InternationalString)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the RegistryPackage instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createService-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createService</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Service.html" title="interface in javax.xml.registry.infomodel">Service</a>&nbsp;createService(java.lang.String&nbsp;name)
               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Service instance using the specified
 name, where the name is a String.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the Service (a String)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Service instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createService-javax.xml.registry.infomodel.InternationalString-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createService</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Service.html" title="interface in javax.xml.registry.infomodel">Service</a>&nbsp;createService(<a href="../../../javax/xml/registry/infomodel/InternationalString.html" title="interface in javax.xml.registry.infomodel">InternationalString</a>&nbsp;name)
               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Service instance using the specified
 name, where the name is an InternationalString.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the Service (an InternationalString)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Service instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createServiceBinding--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceBinding</h4>
<pre><a href="../../../javax/xml/registry/infomodel/ServiceBinding.html" title="interface in javax.xml.registry.infomodel">ServiceBinding</a>&nbsp;createServiceBinding()
                             throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an empty ServiceBinding instance.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ServiceBinding instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createSlot-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSlot</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Slot.html" title="interface in javax.xml.registry.infomodel">Slot</a>&nbsp;createSlot(java.lang.String&nbsp;name,
                java.lang.String&nbsp;value,
                java.lang.String&nbsp;slotType)
         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Slot instance using the specified
 parameters, where the value is a String.


 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the Slot</dd>
<dd><code>value</code> - the value (a String)</dd>
<dd><code>slotType</code> - the slot type</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Slot instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createSlot-java.lang.String-java.util.Collection-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSlot</h4>
<pre><a href="../../../javax/xml/registry/infomodel/Slot.html" title="interface in javax.xml.registry.infomodel">Slot</a>&nbsp;createSlot(java.lang.String&nbsp;name,
                java.util.Collection&nbsp;values,
                java.lang.String&nbsp;slotType)
         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates a Slot instance using the specified
 parameters, where the value is a Collection of Strings.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the Slot</dd>
<dd><code>value</code> - the value (a Collection of Strings)</dd>
<dd><code>slotType</code> - the slot type</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the Slot instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createSpecificationLink--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSpecificationLink</h4>
<pre><a href="../../../javax/xml/registry/infomodel/SpecificationLink.html" title="interface in javax.xml.registry.infomodel">SpecificationLink</a>&nbsp;createSpecificationLink()
                                   throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an empty SpecificationLink instance.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the SpecificationLink instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createTelephoneNumber--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTelephoneNumber</h4>
<pre><a href="../../../javax/xml/registry/infomodel/TelephoneNumber.html" title="interface in javax.xml.registry.infomodel">TelephoneNumber</a>&nbsp;createTelephoneNumber()
                               throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an empty TelephoneNumber instance.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the TelephoneNumber instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="createUser--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createUser</h4>
<pre><a href="../../../javax/xml/registry/infomodel/User.html" title="interface in javax.xml.registry.infomodel">User</a>&nbsp;createUser()
         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Creates an empty User instance.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the User instance created</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="saveObjects-java.util.Collection-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>saveObjects</h4>
<pre><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a>&nbsp;saveObjects(java.util.Collection&nbsp;objects)
                  throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Saves one or more Objects to the registry. An object may be a RegistryObject
 subclass instance.
 <p>If an object is not in the registry, it is created in the registry.
 If it already exists in the registry and has been modified, then its
 state is updated (replaced) in the registry.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>objects</code> - a potentially heterogeneous Collection of RegistryObject instances</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a BulkResponse containing the Collection of keys for those objects that were
 saved successfully and any SaveException that was encountered in case of partial commit</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="deprecateObjects-java.util.Collection-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deprecateObjects</h4>
<pre><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a>&nbsp;deprecateObjects(java.util.Collection&nbsp;keys)
                       throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Deprecates one or more previously submitted objects. Deprecation marks an
 object as "soon to be deleted".
 Once an object is deprecated, the JAXR provider must not allow any new references (e.g. new Associations, Classifications and ExternalLinks) to that object to be submitted. If a client makes an API call that results in a new reference to a deprecated object, the JAXR provider must throw a java.lang.IllegalStateException within a JAXRException. However, existing references to a deprecated object continue to function normally.

 <p><DL><DT><B>Capability Level: 1 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keys</code> - a Collection of keys for the objects to be deprecated</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a BulkResponse containing the Collection of keys for those objects that were
 deprecated successfully and any JAXRException that was encountered in case of partial commit</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="unDeprecateObjects-java.util.Collection-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unDeprecateObjects</h4>
<pre><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a>&nbsp;unDeprecateObjects(java.util.Collection&nbsp;keys)
                         throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Undeprecates one or more previously deprecated objects. If an object
 was not previously deprecated, it is not an error, and no exception
 is thrown.
 Once an object is undeprecated, the JAXR provider must again allow new references (e.g. new Associations, Classifications and ExternalLinks) to that object to be submitted.

 <p><DL><DT><B>Capability Level: 1 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keys</code> - a Collection of keys for the objects to be undeprecated</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a BulkResponse containing the Collection of keys for those objects that were
 deprecated successfully and any JAXRException that was encountered in case of partial commit</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="deleteObjects-java.util.Collection-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deleteObjects</h4>
<pre><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a>&nbsp;deleteObjects(java.util.Collection&nbsp;keys)
                    throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Deletes one or more previously submitted objects from the registry
 using the object keys.

 <p><DL><DT><B>Capability Level: 1 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keys</code> - a Collection of keys for the objects to be deleted</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a BulkResponse containing the Collection of keys for those objects that were
 deleted successfully and any DeleteException that was encountered in case of partial commit</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="deleteObjects-java.util.Collection-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deleteObjects</h4>
<pre><a href="../../../javax/xml/registry/BulkResponse.html" title="interface in javax.xml.registry">BulkResponse</a>&nbsp;deleteObjects(java.util.Collection&nbsp;keys,
                           java.lang.String&nbsp;objectType)
                    throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Deletes one or more previously submitted objects from the registry
 using the object keys and a specified objectType attribute.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keys</code> - a Collection of keys for the objects to be deleted</dd>
<dd><code>objectType</code> - the objectType attribute for the objects to be deleted</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a BulkResponse containing the Collection of keys for those objects that were
 deleted successfully and any DeleteException that was encountered in case of partial commit</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
<a name="getRegistryService--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>getRegistryService</h4>
<pre><a href="../../../javax/xml/registry/RegistryService.html" title="interface in javax.xml.registry">RegistryService</a>&nbsp;getRegistryService()
                            throws <a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></pre>
<div class="block">Returns the parent RegistryService that created this object.

 <p><DL><DT><B>Capability Level: 0 </B></DL></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the parent RegistryService</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../javax/xml/registry/JAXRException.html" title="class in javax.xml.registry">JAXRException</a></code> - if the JAXR provider encounters an internal error</dd>
</dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../index-all.html">Index</a></li>
<li><a href="../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../javax/xml/registry/JAXRResponse.html" title="interface in javax.xml.registry"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../javax/xml/registry/Query.html" title="interface in javax.xml.registry"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?javax/xml/registry/LifeCycleManager.html" target="_top">Frames</a></li>
<li><a href="LifeCycleManager.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</body>
</html>
