<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--NewPage-->
<HTML>
<HEAD>
<TITLE>
Index
</TITLE>


<LINK REL ="stylesheet" TYPE="text/css" HREF="./stylesheet.css" TITLE="Style">

<SCRIPT type="text/javascript">
function windowTitle()
{
    if (location.href.indexOf('is-external=true') == -1) {
        parent.document.title="Index";
    }
}
</SCRIPT>
<NOSCRIPT>
</NOSCRIPT>

</HEAD>

<BODY BGCOLOR="white" onload="windowTitle();">
<HR>


<!-- ========= START OF TOP NAVBAR ======= -->
<A NAME="navbar_top"><!-- --></A>
<A HREF="#skip-navbar_top" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_top_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_top"></A>
<!-- ========= END OF TOP NAVBAR ========= -->

<A HREF="#_A_">A</A> <A HREF="#_B_">B</A> <A HREF="#_C_">C</A> <A HREF="#_D_">D</A> <A HREF="#_E_">E</A> <A HREF="#_F_">F</A> <A HREF="#_G_">G</A> <A HREF="#_H_">H</A> <A HREF="#_I_">I</A> <A HREF="#_L_">L</A> <A HREF="#_M_">M</A> <A HREF="#_N_">N</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_R_">R</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_U_">U</A> <A HREF="#_V_">V</A> <A HREF="#_W_">W</A> <HR>
<A NAME="_A_"><!-- --></A><H2>
<B>A</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html" title="class in com.google.enterprise.adaptor"><B>AbstractAdaptor</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Provides a reasonable default implementation for most <A HREF="./com/google/enterprise/adaptor/Adaptor.html" title="interface in com.google.enterprise.adaptor"><CODE>Adaptor</CODE></A>
 methods.<DT><A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html#AbstractAdaptor()"><B>AbstractAdaptor()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html" title="class in com.google.enterprise.adaptor">AbstractAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor"><B>Acl</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Immutable access control list.<DT><A HREF="./com/google/enterprise/adaptor/Acl.BatchRetriever.html" title="interface in com.google.enterprise.adaptor"><B>Acl.BatchRetriever</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Batch retrieval of ACLs for efficent processing of many authz checks at
 once.<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor"><B>Acl.Builder</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Mutable ACL for creating instances of <A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor"><CODE>Acl</CODE></A>.<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#Acl.Builder()"><B>Acl.Builder()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Create new empty builder.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#Acl.Builder(com.google.enterprise.adaptor.Acl)"><B>Acl.Builder(Acl)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Create and initialize builder with ACL information provided in <code>acl</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.InheritanceType.html" title="enum in com.google.enterprise.adaptor"><B>Acl.InheritanceType</B></A> - Enum in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>The rule for combining a parent's authz response with its child's.<DT><A HREF="./com/google/enterprise/adaptor/Adaptor.html" title="interface in com.google.enterprise.adaptor"><B>Adaptor</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for user-specific implementation details of an Adaptor.<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor"><B>AdaptorContext</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Methods for an Adaptor to communicate with the adaptor library.<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples"><B>AdaptorTemplate</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>Demonstrates what code is necessary for putting public
 content onto a GSA.<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html#AdaptorTemplate()"><B>AdaptorTemplate()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html" title="class in com.google.enterprise.adaptor.examples"><B>AdaptorWithCrawlTimeMetadataTemplate</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>Demonstrates what code is necessary for putting restricted
 content onto a GSA.<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html#AdaptorWithCrawlTimeMetadataTemplate()"><B>AdaptorWithCrawlTimeMetadataTemplate()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorWithCrawlTimeMetadataTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#add(java.lang.String, java.lang.String)"><B>add(String, String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Increases values mapped to k with v.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#addAnchor(java.net.URI, java.lang.String)"><B>addAnchor(URI, String)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Add a hyperlink for the GSA to follow without modifying the document
 contents.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#addKey(java.lang.String, java.lang.String)"><B>addKey(String, String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Add configuration key.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#addMetadata(java.lang.String, java.lang.String)"><B>addMetadata(String, String)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Add metadata element that applies to the document.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#addStatusSource(com.google.enterprise.adaptor.StatusSource)"><B>addStatusSource(StatusSource)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Add a status source to the dashboard.
<DT><A HREF="./com/google/enterprise/adaptor/Application.html" title="class in com.google.enterprise.adaptor"><B>Application</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Provides framework for adaptors to act as a stand-alone application.<DT><A HREF="./com/google/enterprise/adaptor/Application.html#Application(com.google.enterprise.adaptor.Adaptor, com.google.enterprise.adaptor.Config)"><B>Application(Adaptor, Config)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Application.html" title="class in com.google.enterprise.adaptor">Application</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/AuthnAuthority.html#authenticateUser(com.sun.net.httpserver.HttpExchange, com.google.enterprise.adaptor.AuthnAuthority.Callback)"><B>authenticateUser(HttpExchange, AuthnAuthority.Callback)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthnAuthority.html" title="interface in com.google.enterprise.adaptor">AuthnAuthority</A>
<DD>Authenticate the user connected via <code>ex</code>.
<DT><A HREF="./com/google/enterprise/adaptor/AuthnAuthority.html" title="interface in com.google.enterprise.adaptor"><B>AuthnAuthority</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for adaptors capable of authenticating users.<DT><A HREF="./com/google/enterprise/adaptor/AuthnAuthority.Callback.html" title="interface in com.google.enterprise.adaptor"><B>AuthnAuthority.Callback</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for replying to <A HREF="./com/google/enterprise/adaptor/AuthnAuthority.html#authenticateUser(com.sun.net.httpserver.HttpExchange, com.google.enterprise.adaptor.AuthnAuthority.Callback)"><CODE>AuthnAdaptor.authenticateUser(HttpExchange, Callback)</CODE></A>.<DT><A HREF="./com/google/enterprise/adaptor/AuthnIdentity.html" title="interface in com.google.enterprise.adaptor"><B>AuthnIdentity</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>User identification information for understanding who a user is or if they
 are allowed to access a resource.<DT><A HREF="./com/google/enterprise/adaptor/AuthzAuthority.html" title="interface in com.google.enterprise.adaptor"><B>AuthzAuthority</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for adaptors capable of authorizing users.<DT><A HREF="./com/google/enterprise/adaptor/AuthzStatus.html" title="enum in com.google.enterprise.adaptor"><B>AuthzStatus</B></A> - Enum in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Authorization status codes.</DL>
<HR>
<A NAME="_B_"><!-- --></A><H2>
<B>B</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#build()"><B>build()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Create immutable <A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor"><CODE>Acl</CODE></A> instance of the current state.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#build()"><B>build()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Creates single instance of Record.
</DL>
<HR>
<A NAME="_C_"><!-- --></A><H2>
<B>C</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#checkAndScheduleImmediatePushOfDocIds()"><B>checkAndScheduleImmediatePushOfDocIds()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor">GsaCommunicationHandler</A>
<DD>Ensure there is a push running right now.
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#checkAndScheduleIncrementalPushOfDocIds()"><B>checkAndScheduleIncrementalPushOfDocIds()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor">GsaCommunicationHandler</A>
<DD>Perform an push of incremental changes.
<DT><A HREF="./com/google/enterprise/adaptor/package-summary.html"><B>com.google.enterprise.adaptor</B></A> - package com.google.enterprise.adaptor<DD>Adaptor interfaces and implementation.<DT><A HREF="./com/google/enterprise/adaptor/examples/package-summary.html"><B>com.google.enterprise.adaptor.examples</B></A> - package com.google.enterprise.adaptor.examples<DD>&nbsp;<DT><A HREF="./com/google/enterprise/adaptor/experimental/package-summary.html"><B>com.google.enterprise.adaptor.experimental</B></A> - package com.google.enterprise.adaptor.experimental<DD>&nbsp;<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html"><B>com.google.enterprise.adaptor.prebuilt</B></A> - package com.google.enterprise.adaptor.prebuilt<DD>&nbsp;<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>Command</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Exec helper that allows easy handling of stdin, stdout, and stderr.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>Command.Result</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Result data from an invocation<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html#Command.Result(int, byte[], byte[])"><B>Command.Result(int, byte[], byte[])</B></A> - 
Constructor for class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html" title="class in com.google.enterprise.adaptor.prebuilt">Command.Result</A>
<DD>Construct a result.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>CommandLineAdaptor</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Command Line Adaptor<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#CommandLineAdaptor()"><B>CommandLineAdaptor()</B></A> - 
Constructor for class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>CommandLineTransform</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>A conduit that allows a simple way to create a document transform based on
 a command line program.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#CommandLineTransform()"><B>CommandLineTransform()</B></A> - 
Constructor for class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html" title="class in com.google.enterprise.adaptor"><B>CommandStreamParser</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Parses the adaptor data format into individual commands with associated data.<DT><A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html#CommandStreamParser(java.io.InputStream)"><B>CommandStreamParser(InputStream)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html" title="class in com.google.enterprise.adaptor">CommandStreamParser</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocId.html#compareTo(com.google.enterprise.adaptor.DocId)"><B>compareTo(DocId)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocId.html" title="class in com.google.enterprise.adaptor">DocId</A>
<DD>Provides comparison for ids based on the unique id string.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#compareTo(com.google.enterprise.adaptor.Principal)"><B>compareTo(Principal)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>Sorts by 1) namespace, 2) user or group, 3) name.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor"><B>Config</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Configuration values for this program, like the GSA's hostname.<DT><A HREF="./com/google/enterprise/adaptor/Config.html#Config()"><B>Config()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html#copyMetadata(java.util.Map)"><B>copyMetadata(Map&lt;String, String&gt;)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html" title="class in com.google.enterprise.adaptor.prebuilt">PrebuiltTransforms</A>
<DD>Returns a transform that copies metadata values from one key to another.
<DT><A HREF="./com/google/enterprise/adaptor/IOHelper.html#copyStream(java.io.InputStream, java.io.OutputStream)"><B>copyStream(InputStream, OutputStream)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/IOHelper.html" title="class in com.google.enterprise.adaptor">IOHelper</A>
<DD>Copy contents of <code>in</code> to <code>out</code>.
<DT><A HREF="./com/google/enterprise/adaptor/examples/MetadataTransformExample.html#create(java.util.Map)"><B>create(Map&lt;String, String&gt;)</B></A> - 
Static method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/MetadataTransformExample.html" title="class in com.google.enterprise.adaptor.examples">MetadataTransformExample</A>
<DD>Makes transform from config with "src" and "dest" keys.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#create(java.util.Map)"><B>create(Map&lt;String, String&gt;)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>Accepts keys <code>"cmd"</code>, <code>"workingDirectory"</code>, and <code>"arg?"</code>.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#createHttpContext(java.lang.String, com.sun.net.httpserver.HttpHandler)"><B>createHttpContext(String, HttpHandler)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Registers a handler with the library's <A HREF="http://download.oracle.com/javase/6/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpServer.html?is-external=true" title="class or interface in com.sun.net.httpserver"><CODE>HttpServer</CODE></A> in similar fashion to <A HREF="http://download.oracle.com/javase/6/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpServer.html?is-external=true#createContext(java.lang.String, com.sun.net.httpserver.HttpHandler)" title="class or interface in com.sun.net.httpserver"><CODE>HttpServer.createContext(java.lang.String, com.sun.net.httpserver.HttpHandler)</CODE></A>.
<DT><A HREF="./com/google/enterprise/adaptor/CustomFormatter.html" title="class in com.google.enterprise.adaptor"><B>CustomFormatter</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Custom log formatter for ease of development.<DT><A HREF="./com/google/enterprise/adaptor/CustomFormatter.html#CustomFormatter()"><B>CustomFormatter()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CustomFormatter.html" title="class in com.google.enterprise.adaptor">CustomFormatter</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_D_"><!-- --></A><H2>
<B>D</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Daemon.html" title="class in com.google.enterprise.adaptor"><B>Daemon</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Allows running an adaptor as a daemon when used in conjunction with procrun
 or jsvc.<DT><A HREF="./com/google/enterprise/adaptor/Daemon.html#Daemon()"><B>Daemon()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Daemon.html" title="class in com.google.enterprise.adaptor">Daemon</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples"><B>DbAdaptorTemplate</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>Demonstrates what code is necessary for putting DB
 content onto a GSA.<DT><A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html#DbAdaptorTemplate()"><B>DbAdaptorTemplate()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">DbAdaptorTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/SensitiveValueDecoder.html#decodeValue(java.lang.String)"><B>decodeValue(String)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/SensitiveValueDecoder.html" title="interface in com.google.enterprise.adaptor">SensitiveValueDecoder</A>
<DD>Decode an encoded sensitive string into its original string.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#DEFAULT_NAMESPACE"><B>DEFAULT_NAMESPACE</B></A> - 
Static variable in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/ExceptionHandlers.html#defaultHandler()"><B>defaultHandler()</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/ExceptionHandlers.html" title="class in com.google.enterprise.adaptor">ExceptionHandlers</A>
<DD>The default exception handler.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html#deleteMetadata(java.util.Map)"><B>deleteMetadata(Map&lt;String, String&gt;)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html" title="class in com.google.enterprise.adaptor.prebuilt">PrebuiltTransforms</A>
<DD>Returns a transform that deletes metadata keys.
<DT><A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html#destroy()"><B>destroy()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html" title="class in com.google.enterprise.adaptor">AbstractAdaptor</A>
<DD>Shutdown and release resources of adaptor.
<DT><A HREF="./com/google/enterprise/adaptor/Adaptor.html#destroy()"><B>destroy()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Adaptor.html" title="interface in com.google.enterprise.adaptor">Adaptor</A>
<DD>Shutdown and release resources of adaptor.
<DT><A HREF="./com/google/enterprise/adaptor/Daemon.html#destroy()"><B>destroy()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Daemon.html" title="class in com.google.enterprise.adaptor">Daemon</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocId.html" title="class in com.google.enterprise.adaptor"><B>DocId</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Refers to a unique document in repository.<DT><A HREF="./com/google/enterprise/adaptor/DocId.html#DocId(java.lang.String)"><B>DocId(String)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocId.html" title="class in com.google.enterprise.adaptor">DocId</A>
<DD>Construct an identifier based on <code>id</code>.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdEncoder.html" title="interface in com.google.enterprise.adaptor"><B>DocIdEncoder</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Allows generating a URI for a particular DocId.<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><B>DocIdPusher</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface that allows at-will pushing of <code>DocId</code>s to the GSA.<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor"><B>DocIdPusher.Record</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Immutable feed attributes for a document identified by its <code>DocId</code>.<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor"><B>DocIdPusher.Record.Builder</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Builder to create instances of Record.<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#DocIdPusher.Record.Builder(com.google.enterprise.adaptor.DocId)"><B>DocIdPusher.Record.Builder(DocId)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Create mutable builder for building <A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor"><CODE>DocIdPusher.Record</CODE></A> instances.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#DocIdPusher.Record.Builder(com.google.enterprise.adaptor.DocIdPusher.Record)"><B>DocIdPusher.Record.Builder(DocIdPusher.Record)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Create mutable builder initialized to values provided by <code>startPoint</code>.
<DT><A HREF="./com/google/enterprise/adaptor/DocumentTransform.html" title="interface in com.google.enterprise.adaptor"><B>DocumentTransform</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Represents an individual transform in the transform pipeline.</DL>
<HR>
<A NAME="_E_"><!-- --></A><H2>
<B>E</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#EMPTY"><B>EMPTY</B></A> - 
Static variable in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Empty convenience instance with all defaults used.
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html#enableCompressionIfSupported(com.sun.net.httpserver.HttpExchange)"><B>enableCompressionIfSupported(HttpExchange)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor">HttpExchanges</A>
<DD>If the client supports it, set the correct headers and streams to provide
 GZIPed response data to the client.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdEncoder.html#encodeDocId(com.google.enterprise.adaptor.DocId)"><B>encodeDocId(DocId)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdEncoder.html" title="interface in com.google.enterprise.adaptor">DocIdEncoder</A>
<DD>Encode the provided DocId into a URI.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#ensureLatestConfigLoaded()"><B>ensureLatestConfigLoaded()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Equality is determined if all the permit/deny sets are equal and the
 inheritance is equal.
<DT><A HREF="./com/google/enterprise/adaptor/DocId.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocId.html" title="class in com.google.enterprise.adaptor">DocId</A>
<DD>Determines equality based on the unique id string.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>Checks for equality based on all visible fields.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>True if exactly the same key-values are represented.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#equals(java.lang.Object)"><B>equals(Object)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html" title="interface in com.google.enterprise.adaptor"><B>ExceptionHandler</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for handling errors and handling retrying policy.<DT><A HREF="./com/google/enterprise/adaptor/ExceptionHandlers.html" title="class in com.google.enterprise.adaptor"><B>ExceptionHandlers</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Utility class for <A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html" title="interface in com.google.enterprise.adaptor"><CODE>ExceptionHandler</CODE></A>s.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html#exec(java.lang.String[])"><B>exec(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html" title="class in com.google.enterprise.adaptor.prebuilt">Command</A>
<DD>Same as <code>exec(command, null, new byte[0])</code>.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html#exec(java.lang.String[], java.io.File)"><B>exec(String[], File)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html" title="class in com.google.enterprise.adaptor.prebuilt">Command</A>
<DD>Same as <code>exec(command, workingDir, new byte[0])</code>.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html#exec(java.lang.String[], byte[])"><B>exec(String[], byte[])</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html" title="class in com.google.enterprise.adaptor.prebuilt">Command</A>
<DD>Same as <code>exec(command, null, stdin)</code>.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html#exec(java.lang.String[], java.io.File, byte[])"><B>exec(String[], File, byte[])</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html" title="class in com.google.enterprise.adaptor.prebuilt">Command</A>
<DD>Create process <code>command</code> starting in the <code>workingDir</code> and
 providing <code>stdin</code> as input.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html#exec(java.lang.String[], com.google.enterprise.adaptor.prebuilt.StreamingCommand.InputSource, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink)"><B>exec(String[], StreamingCommand.InputSource, StreamingCommand.OutputSink, StreamingCommand.OutputSink)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand</A>
<DD>Same as <code>exec(command, null, stdin, stdout, stderr)</code>.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html#exec(java.lang.String[], java.io.File, com.google.enterprise.adaptor.prebuilt.StreamingCommand.InputSource, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink)"><B>exec(String[], File, StreamingCommand.InputSource, StreamingCommand.OutputSink, StreamingCommand.OutputSink)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand</A>
<DD>Create process <code>command</code> starting in the <code>workingDir</code> and
 providing <code>stdin</code> as input.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#executeAuthorizer(java.lang.String[], byte[])"><B>executeAuthorizer(String[], byte[])</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#executeLister(java.lang.String[], com.google.enterprise.adaptor.prebuilt.StreamingCommand.InputSource, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink)"><B>executeLister(String[], StreamingCommand.InputSource, StreamingCommand.OutputSink, StreamingCommand.OutputSink)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#executeRetriever(java.lang.String[], com.google.enterprise.adaptor.prebuilt.StreamingCommand.InputSource, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink, com.google.enterprise.adaptor.prebuilt.StreamingCommand.OutputSink)"><B>executeRetriever(String[], StreamingCommand.InputSource, StreamingCommand.OutputSink, StreamingCommand.OutputSink)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/ExceptionHandlers.html#exponentialBackoffHandler(int, long, java.util.concurrent.TimeUnit)"><B>exponentialBackoffHandler(int, long, TimeUnit)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/ExceptionHandlers.html" title="class in com.google.enterprise.adaptor">ExceptionHandlers</A>
<DD>Create a handler that uses exponential backoff to sleep before retrying.
</DL>
<HR>
<A NAME="_F_"><!-- --></A><H2>
<B>F</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.examples"><B>FileSystemAdaptor</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>Simple example adaptor that serves files from the local filesystem.<DT><A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html#FileSystemAdaptor()"><B>FileSystemAdaptor()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.examples">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>FileSystemAdaptor</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Adaptor serving files from current directory<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html#FileSystemAdaptor()"><B>FileSystemAdaptor()</B></A> - 
Constructor for class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/CustomFormatter.html#format(java.util.logging.LogRecord)"><B>format(LogRecord)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CustomFormatter.html" title="class in com.google.enterprise.adaptor">CustomFormatter</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_G_"><!-- --></A><H2>
<B>G</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#getAdaptor()"><B>getAdaptor()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor">GsaCommunicationHandler</A>
<DD>The adaptor instance being used.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getAllKeys()"><B>getAllKeys()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#getAllValues(java.lang.String)"><B>getAllValues(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Gives unmodifiable reference to inserted values for key, empty if none.
<DT><A HREF="./com/google/enterprise/adaptor/Session.html#getAttribute(java.lang.String)"><B>getAttribute(String)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Session.html" title="interface in com.google.enterprise.adaptor">Session</A>
<DD>Get attribute value.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.WrappedIOException.html#getCause()"><B>getCause()</B></A> - 
Method in exception com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.WrappedIOException.html" title="class in com.google.enterprise.adaptor.prebuilt">RecursiveFileIterator.WrappedIOException</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Status.html#getCode()"><B>getCode()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Status.html" title="interface in com.google.enterprise.adaptor">Status</A>
<DD>The code to represent the state of the status.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#getCommandAcceptsParameters()"><B>getCommandAcceptsParameters()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#getConfig()"><B>getConfig()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Configuration instance for the adaptor and all things within the adaptor
 library.
<DT><A HREF="./com/google/enterprise/adaptor/Application.html#getConfig()"><B>getConfig()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Application.html" title="class in com.google.enterprise.adaptor">Application</A>
<DD>Returns the <A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor"><CODE>Config</CODE></A> used by this instance.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getDenies()"><B>getDenies()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns immutable set of denied users and groups;
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getDenyGroups()"><B>getDenyGroups()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns immutable set of denied groups.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getDenyUsers()"><B>getDenyUsers()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns immutable set of denied users.
<DT><A HREF="./com/google/enterprise/adaptor/AuthzStatus.html#getDescription()"><B>getDescription()</B></A> - 
Method in enum com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthzStatus.html" title="enum in com.google.enterprise.adaptor">AuthzStatus</A>
<DD>Get a short description of the status.
<DT><A HREF="./com/google/enterprise/adaptor/Adaptor.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Adaptor.html" title="interface in com.google.enterprise.adaptor">Adaptor</A>
<DD>Provides contents and metadata of particular document.
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorTemplate</A>
<DD>Gives the bytes of a document referenced with id.
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorWithCrawlTimeMetadataTemplate</A>
<DD>Gives the bytes of a document referenced with id.
<DT><A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">DbAdaptorTemplate</A>
<DD>Gives the bytes of a document referenced with id.
<DT><A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.examples">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html" title="class in com.google.enterprise.adaptor.examples">GroupDefinitionsWriter</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>Gives the bytes of a document referenced with id.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><B>getDocContent(Request, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#getDocId()"><B>getDocId()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>The identifier for the document this record is providing information for.
<DT><A HREF="./com/google/enterprise/adaptor/Request.html#getDocId()"><B>getDocId()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Request.html" title="interface in com.google.enterprise.adaptor">Request</A>
<DD>Provides the document ID for the document that is being requested.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#getDocIdEncoder()"><B>getDocIdEncoder()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>A way to construct URIs from DocIds.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#getDocIdPusher()"><B>getDocIdPusher()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Callback object for pushing <code>DocId</code>s to the GSA at any time.
<DT><A HREF="./com/google/enterprise/adaptor/Adaptor.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Adaptor.html" title="interface in com.google.enterprise.adaptor">Adaptor</A>
<DD>Pushes all the <code>DocId</code>s that are suppose to be indexed by the GSA.
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorTemplate</A>
<DD>Gives list of document ids that you'd like on the GSA.
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorWithCrawlTimeMetadataTemplate</A>
<DD>Gives list of document ids that you'd like on the GSA.
<DT><A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">DbAdaptorTemplate</A>
<DD>Get all doc ids from database.
<DT><A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.examples">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html" title="class in com.google.enterprise.adaptor.examples">GroupDefinitionsWriter</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getDocIds(DocIdPusher)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#getGetDocIdsFullErrorHandler()"><B>getGetDocIdsFullErrorHandler()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Retrieve the current <A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html" title="interface in com.google.enterprise.adaptor"><CODE>ExceptionHandler</CODE></A> for full push.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#getGetDocIdsIncrementalErrorHandler()"><B>getGetDocIdsIncrementalErrorHandler()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Retrieve the current <A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html" title="interface in com.google.enterprise.adaptor"><CODE>ExceptionHandler</CODE></A> for incremental push.
<DT><A HREF="./com/google/enterprise/adaptor/AuthnIdentity.html#getGroups()"><B>getGroups()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthnIdentity.html" title="interface in com.google.enterprise.adaptor">AuthnIdentity</A>
<DD>Gets all the groups a user belongs to in an immutable set.
<DT><A HREF="./com/google/enterprise/adaptor/Application.html#getGsaCommunicationHandler()"><B>getGsaCommunicationHandler()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Application.html" title="class in com.google.enterprise.adaptor">Application</A>
<DD>Returns the <A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor"><CODE>GsaCommunicationHandler</CODE></A> used by this instance.
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html#getIfModifiedSince(com.sun.net.httpserver.HttpExchange)"><B>getIfModifiedSince(HttpExchange)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor">HttpExchanges</A>
<DD>Retrieves and parses the If-Modified-Since from the request, returning null
 if there was no such header or there was an error.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getInheritanceType()"><B>getInheritanceType()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns the inheritance type used to combine authz decisions of these ACLs
 with its <em>child</em>.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getInheritFrom()"><B>getInheritFrom()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns <code>DocId</code> these ACLs are inherited from.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getInheritFromFragment()"><B>getInheritFromFragment()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns fragment, if there is one, that specifies which of the parent's
 ACLs is to to be inhertied from.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#getKeys()"><B>getKeys()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Get modifiable set of all keys with at least one value.
<DT><A HREF="./com/google/enterprise/adaptor/Request.html#getLastAccessTime()"><B>getLastAccessTime()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Request.html" title="interface in com.google.enterprise.adaptor">Request</A>
<DD>Returns the last time a GSA or other client retrieved the data, or <code>null</code> if none was provided by the client.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#getLastModified()"><B>getLastModified()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>The last modified date of the document.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#getListerCommand()"><B>getListerCommand()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getListOfConfigs(java.lang.String)"><B>getListOfConfigs(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Returns a list of maps corresponding to each item of the comma-separated
 value of <code>key</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Status.html#getMessage(java.util.Locale)"><B>getMessage(Locale)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Status.html" title="interface in com.google.enterprise.adaptor">Status</A>
<DD>A message appropriate for displaying to an end-user concerning the state of
 the status.
<DT><A HREF="./com/google/enterprise/adaptor/PollingIncrementalLister.html#getModifiedDocIds(com.google.enterprise.adaptor.DocIdPusher)"><B>getModifiedDocIds(DocIdPusher)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/PollingIncrementalLister.html" title="interface in com.google.enterprise.adaptor">PollingIncrementalLister</A>
<DD>Check for documents modified since the last call to the method.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#getName()"><B>getName()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/StatusSource.html#getName(java.util.Locale)"><B>getName(Locale)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/StatusSource.html" title="interface in com.google.enterprise.adaptor">StatusSource</A>
<DD>Get the name of this source, for displaying to the user.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#getNamespace()"><B>getNamespace()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#getOneValue(java.lang.String)"><B>getOneValue(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>One of the inserted values, or null if none.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#getOutputStream()"><B>getOutputStream()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Get stream to write document contents to.
<DT><A HREF="./com/google/enterprise/adaptor/AuthnIdentity.html#getPassword()"><B>getPassword()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthnIdentity.html" title="interface in com.google.enterprise.adaptor">AuthnIdentity</A>
<DD>Gets the user's password.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getPermitGroups()"><B>getPermitGroups()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns immutable set of permitted groups.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getPermits()"><B>getPermits()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns immutable set of permitted users and groups.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#getPermitUsers()"><B>getPermitUsers()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns immutable set of permitted users.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getRawValue(java.lang.String)"><B>getRawValue(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Get a configuration value exactly as provided in configuration.
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html#getRequestUri(com.sun.net.httpserver.HttpExchange)"><B>getRequestUri(HttpExchange)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor">HttpExchanges</A>
<DD>Best-effort attempt to reform the identical URI the client used to
 contact the server.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#getResultLink()"><B>getResultLink()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>The URI that should be displayed to the user in search results.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#getRetrieverCommand()"><B>getRetrieverCommand()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html#getReturnCode()"><B>getReturnCode()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html" title="class in com.google.enterprise.adaptor.prebuilt">Command.Result</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#getSensitiveValueDecoder()"><B>getSensitiveValueDecoder()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Retrieve decoder for sensitive values, like passwords.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html#getStderr()"><B>getStderr()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html" title="class in com.google.enterprise.adaptor.prebuilt">Command.Result</A>
<DD>Returns internal byte array without copying.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html#getStdout()"><B>getStdout()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/Command.Result.html" title="class in com.google.enterprise.adaptor.prebuilt">Command.Result</A>
<DD>Returns internal byte array without copying.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#getTransformCommand()"><B>getTransformCommand()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocId.html#getUniqueId()"><B>getUniqueId()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocId.html" title="class in com.google.enterprise.adaptor">DocId</A>
<DD>Returns the string identifier provided to the constructor.
<DT><A HREF="./com/google/enterprise/adaptor/AuthnIdentity.html#getUser()"><B>getUser()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthnIdentity.html" title="interface in com.google.enterprise.adaptor">AuthnIdentity</A>
<DD>Gets the user principal.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#getUserSession(com.sun.net.httpserver.HttpExchange, boolean)"><B>getUserSession(HttpExchange, boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Get the session for the user communicating via <code>ex</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getValue(java.lang.String)"><B>getValue(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Get a configuration value as computed based on the configuration.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getValuesWithPrefix(java.lang.String)"><B>getValuesWithPrefix(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Gets all configuration values that begin with <code>prefix</code>, returning
 them as a map with the keys having <code>prefix</code> removed.
<DT><A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html#getVersionNumber()"><B>getVersionNumber()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html" title="class in com.google.enterprise.adaptor">CommandStreamParser</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#getWorkingDirectory()"><B>getWorkingDirectory()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html" title="class in com.google.enterprise.adaptor.examples"><B>GroupDefinitionsWriter</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>Demonstrates sending group definitions to GSA.<DT><A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html#GroupDefinitionsWriter()"><B>GroupDefinitionsWriter()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html" title="class in com.google.enterprise.adaptor.examples">GroupDefinitionsWriter</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html" title="class in com.google.enterprise.adaptor"><B>GroupPrincipal</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Represents group.<DT><A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html#GroupPrincipal(java.lang.String, java.lang.String)"><B>GroupPrincipal(String, String)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html" title="class in com.google.enterprise.adaptor">GroupPrincipal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html#GroupPrincipal(java.lang.String)"><B>GroupPrincipal(String)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html" title="class in com.google.enterprise.adaptor">GroupPrincipal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor"><B>GsaCommunicationHandler</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>This class handles the communications with GSA.<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#GsaCommunicationHandler(com.google.enterprise.adaptor.Adaptor, com.google.enterprise.adaptor.Config)"><B>GsaCommunicationHandler(Adaptor, Config)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor">GsaCommunicationHandler</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_H_"><!-- --></A><H2>
<B>H</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html#handleException(java.lang.Exception, int)"><B>handleException(Exception, int)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html" title="interface in com.google.enterprise.adaptor">ExceptionHandler</A>
<DD>Determine how to proceed after an exception was thrown.
<DT><A HREF="./com/google/enterprise/adaptor/Request.html#hasChangedSinceLastAccess(java.util.Date)"><B>hasChangedSinceLastAccess(Date)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Request.html" title="interface in com.google.enterprise.adaptor">Request</A>
<DD>Returns <code>true</code> if the GSA or other client's current copy of the
 document was retrieved after the <code>lastModified</code> date; <code>false</code>
 otherwise.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#hashCode()"><B>hashCode()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Returns a hash code for this object that agrees with <code>equals</code>.
<DT><A HREF="./com/google/enterprise/adaptor/DocId.html#hashCode()"><B>hashCode()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocId.html" title="class in com.google.enterprise.adaptor">DocId</A>
<DD>Generates a hash code based on the unique id string.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#hashCode()"><B>hashCode()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>Generates hash code based on all visible fields.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#hashCode()"><B>hashCode()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html#hasNext()"><B>hasNext()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html" title="class in com.google.enterprise.adaptor.prebuilt">RecursiveFileIterator</A>
<DD>Returns <code>true</code> if the iteration has more elements.
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html#headersSent(com.sun.net.httpserver.HttpExchange)"><B>headersSent(HttpExchange)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor">HttpExchanges</A>
<DD>Determines if the headers have already been sent for the exchange.
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor"><B>HttpExchanges</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Utility class for working with <A HREF="http://download.oracle.com/javase/6/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpExchange.html?is-external=true" title="class or interface in com.sun.net.httpserver"><CODE>HttpExchange</CODE></A>s.</DL>
<HR>
<A NAME="_I_"><!-- --></A><H2>
<B>I</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html#init(com.google.enterprise.adaptor.AdaptorContext)"><B>init(AdaptorContext)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html" title="class in com.google.enterprise.adaptor">AbstractAdaptor</A>
<DD>Initialize adaptor with the current context.
<DT><A HREF="./com/google/enterprise/adaptor/Adaptor.html#init(com.google.enterprise.adaptor.AdaptorContext)"><B>init(AdaptorContext)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Adaptor.html" title="interface in com.google.enterprise.adaptor">Adaptor</A>
<DD>Initialize adaptor with the current context.
<DT><A HREF="./com/google/enterprise/adaptor/Daemon.html#init(org.apache.commons.daemon.DaemonContext)"><B>init(DaemonContext)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Daemon.html" title="class in com.google.enterprise.adaptor">Daemon</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html#init(com.google.enterprise.adaptor.AdaptorContext)"><B>init(AdaptorContext)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorWithCrawlTimeMetadataTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html#init(com.google.enterprise.adaptor.AdaptorContext)"><B>init(AdaptorContext)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">DbAdaptorTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html#init(com.google.enterprise.adaptor.AdaptorContext)"><B>init(AdaptorContext)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.examples">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#init(com.google.enterprise.adaptor.AdaptorContext)"><B>init(AdaptorContext)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html#init(com.google.enterprise.adaptor.AdaptorContext)"><B>init(AdaptorContext)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html#initConfig(com.google.enterprise.adaptor.Config)"><B>initConfig(Config)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html" title="class in com.google.enterprise.adaptor">AbstractAdaptor</A>
<DD>Provides the opportunity for the Adaptor to create new configuration values
 or override default values.
<DT><A HREF="./com/google/enterprise/adaptor/Adaptor.html#initConfig(com.google.enterprise.adaptor.Config)"><B>initConfig(Config)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Adaptor.html" title="interface in com.google.enterprise.adaptor">Adaptor</A>
<DD>Provides the opportunity for the Adaptor to create new configuration values
 or override default values.
<DT><A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html#initConfig(com.google.enterprise.adaptor.Config)"><B>initConfig(Config)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">DbAdaptorTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html#initConfig(com.google.enterprise.adaptor.Config)"><B>initConfig(Config)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.examples">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#initConfig(com.google.enterprise.adaptor.Config)"><B>initConfig(Config)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html#initConfig(com.google.enterprise.adaptor.Config)"><B>initConfig(Config)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">FileSystemAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/IOHelper.html" title="class in com.google.enterprise.adaptor"><B>IOHelper</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Utility class for providing useful methods when handling streams or other
 forms of I/O.<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#isAuthorized(com.google.enterprise.adaptor.AuthnIdentity, java.util.List)"><B>isAuthorized(AuthnIdentity, List&lt;Acl&gt;)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Determine if the provided <code>userIdentity</code> belonging to <code>groups</code> is authorized for the provided <code>aclChain</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#isAuthorizedBatch(com.google.enterprise.adaptor.AuthnIdentity, java.util.Collection, com.google.enterprise.adaptor.Acl.BatchRetriever)"><B>isAuthorizedBatch(AuthnIdentity, Collection&lt;DocId&gt;, Acl.BatchRetriever)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Check authz for many DocIds at once.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#isAuthorizedLocal(com.google.enterprise.adaptor.AuthnIdentity)"><B>isAuthorizedLocal(AuthnIdentity)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Determine if the provided <code>userIdentifier</code> belonging to <code>groups</code> is authorized, ignoring inheritance.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#isEmpty()"><B>isEmpty()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>True with 0 entries.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#isEverythingCaseInsensitive()"><B>isEverythingCaseInsensitive()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Says whether letter casing doesn't matter during authorization.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#isEverythingCaseSensitive()"><B>isEverythingCaseSensitive()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Says whether letter casing differentiates names during authorization.
<DT><A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html#isGroup()"><B>isGroup()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html" title="class in com.google.enterprise.adaptor">GroupPrincipal</A>
<DD>Always returns <code>true</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#isGroup()"><B>isGroup()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/UserPrincipal.html#isGroup()"><B>isGroup()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/UserPrincipal.html" title="class in com.google.enterprise.adaptor">UserPrincipal</A>
<DD>Always returns <code>false</code>.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#isToBeCrawledImmediately()"><B>isToBeCrawledImmediately()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>Informs the GSA that the document has been modified, and the GSA should
 give high priority to recrawling the document.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#isToBeCrawledOnce()"><B>isToBeCrawledOnce()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>Informs the GSA that it should only crawl the document once.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#isToBeDeleted()"><B>isToBeDeleted()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>Whether the GSA is being informed the document has been deleted.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#isToBeLocked()"><B>isToBeLocked()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>Locks the document into the GSA's index.
<DT><A HREF="./com/google/enterprise/adaptor/CustomFormatter.html#isUseColor()"><B>isUseColor()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CustomFormatter.html" title="class in com.google.enterprise.adaptor">CustomFormatter</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html#isUser()"><B>isUser()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GroupPrincipal.html" title="class in com.google.enterprise.adaptor">GroupPrincipal</A>
<DD>Always returns <code>false</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#isUser()"><B>isUser()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/UserPrincipal.html#isUser()"><B>isUser()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/UserPrincipal.html" title="class in com.google.enterprise.adaptor">UserPrincipal</A>
<DD>Always returns <code>true</code>.
<DT><A HREF="./com/google/enterprise/adaptor/AuthzAuthority.html#isUserAuthorized(com.google.enterprise.adaptor.AuthnIdentity, java.util.Collection)"><B>isUserAuthorized(AuthnIdentity, Collection&lt;DocId&gt;)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthzAuthority.html" title="interface in com.google.enterprise.adaptor">AuthzAuthority</A>
<DD>Determines whether the user identified is allowed to access the <code>DocId</code>s.
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html#isUserAuthorized(com.google.enterprise.adaptor.AuthnIdentity, java.util.Collection)"><B>isUserAuthorized(AuthnIdentity, Collection&lt;DocId&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorWithCrawlTimeMetadataTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#isUserAuthorized(com.google.enterprise.adaptor.AuthnIdentity, java.util.Collection)"><B>isUserAuthorized(AuthnIdentity, Collection&lt;DocId&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>Determines whether the user identified is allowed to access the <code>DocId</code>s.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#iterator()"><B>iterator()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Provides every key and value in immutable entries sorted
 alphabetically, first by key, and secondly by value.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html#iterator()"><B>iterator()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html" title="class in com.google.enterprise.adaptor.prebuilt">RecursiveFileIterator</A>
<DD>Returns <code>this</code> to allow using with foreach loops.
</DL>
<HR>
<A NAME="_L_"><!-- --></A><H2>
<B>L</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#load(java.lang.String)"><B>load(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Load user-provided configuration file.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#load(java.io.File)"><B>load(File)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Load user-provided configuration file.
</DL>
<HR>
<A NAME="_M_"><!-- --></A><H2>
<B>M</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html#main(com.google.enterprise.adaptor.Adaptor, java.lang.String[])"><B>main(Adaptor, String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html" title="class in com.google.enterprise.adaptor">AbstractAdaptor</A>
<DD>Standard main for all adaptors (including those not extending
 AbstractAdaptor).
<DT><A HREF="./com/google/enterprise/adaptor/Application.html#main(com.google.enterprise.adaptor.Adaptor, java.lang.String[])"><B>main(Adaptor, String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Application.html" title="class in com.google.enterprise.adaptor">Application</A>
<DD>Main for adaptors to utilize when wanting to act as an application.
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorTemplate</A>
<DD>Call default main for adaptors.
<DT><A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/AdaptorWithCrawlTimeMetadataTemplate.html" title="class in com.google.enterprise.adaptor.examples">AdaptorWithCrawlTimeMetadataTemplate</A>
<DD>Call default main for adaptors.
<DT><A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/DbAdaptorTemplate.html" title="class in com.google.enterprise.adaptor.examples">DbAdaptorTemplate</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.examples">FileSystemAdaptor</A>
<DD>Call default main for adaptors.
<DT><A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/GroupDefinitionsWriter.html" title="class in com.google.enterprise.adaptor.examples">GroupDefinitionsWriter</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/experimental/Sim.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.experimental.<A HREF="./com/google/enterprise/adaptor/experimental/Sim.html" title="class in com.google.enterprise.adaptor.experimental">Sim</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>Call default main for adaptors.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html#main(java.lang.String[])"><B>main(String[])</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/FileSystemAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">FileSystemAdaptor</A>
<DD>Call default main for adaptors.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor"><B>Metadata</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Allows storing multiple metadata values to a single key.<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#Metadata()"><B>Metadata()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Create empty instance.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#Metadata(java.lang.Iterable)"><B>Metadata(Iterable&lt;Map.Entry&lt;String, String&gt;&gt;)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Duplicate.
<DT><A HREF="./com/google/enterprise/adaptor/examples/MetadataTransformExample.html" title="class in com.google.enterprise.adaptor.examples"><B>MetadataTransformExample</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>Example transform which will move values from one key to another.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html#moveMetadata(java.util.Map)"><B>moveMetadata(Map&lt;String, String&gt;)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html" title="class in com.google.enterprise.adaptor.prebuilt">PrebuiltTransforms</A>
<DD>Returns a transform that moves metadata values from one key to another.
</DL>
<HR>
<A NAME="_N_"><!-- --></A><H2>
<B>N</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html#next()"><B>next()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html" title="class in com.google.enterprise.adaptor.prebuilt">RecursiveFileIterator</A>
<DD>Returns the next file in the iteratior.
<DT><A HREF="./com/google/enterprise/adaptor/ExceptionHandlers.html#noRetryHandler()"><B>noRetryHandler()</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/ExceptionHandlers.html" title="class in com.google.enterprise.adaptor">ExceptionHandlers</A>
<DD>Create a handler that always returns <code>false</code>, causing no retries.
</DL>
<HR>
<A NAME="_O_"><!-- --></A><H2>
<B>O</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#overrideKey(java.lang.String, java.lang.String)"><B>overrideKey(String, String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>Change the default value of a preexisting configuration key.
</DL>
<HR>
<A NAME="_P_"><!-- --></A><H2>
<B>P</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html#parseQueryParameters(com.sun.net.httpserver.HttpExchange, java.nio.charset.Charset)"><B>parseQueryParameters(HttpExchange, Charset)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor">HttpExchanges</A>
<DD>Parse request GET query parameters of <code>ex</code> into its parts, correctly
 taking into account <code>charset</code>.
<DT><A HREF="./com/google/enterprise/adaptor/experimental/Sim.html#percentDecode(java.lang.String)"><B>percentDecode(String)</B></A> - 
Static method in class com.google.enterprise.adaptor.experimental.<A HREF="./com/google/enterprise/adaptor/experimental/Sim.html" title="class in com.google.enterprise.adaptor.experimental">Sim</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/PollingIncrementalLister.html" title="interface in com.google.enterprise.adaptor"><B>PollingIncrementalLister</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for library-assisted polling incremental adaptors.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>PrebuiltTransforms</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Common transforms that you would expect to have available.<DT><A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor"><B>Principal</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Represents either a user or a group.<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushDocIds(java.lang.Iterable)"><B>pushDocIds(Iterable&lt;DocId&gt;)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Push <code>DocId</code>s immediately and block until they are successfully
 provided to the GSA or the error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushDocIds(java.lang.Iterable, com.google.enterprise.adaptor.ExceptionHandler)"><B>pushDocIds(Iterable&lt;DocId&gt;, ExceptionHandler)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Push <code>DocId</code>s immediately and block until they are successfully
 provided to the GSA or the error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushGroupDefinitions(java.util.Map, boolean)"><B>pushGroupDefinitions(Map&lt;GroupPrincipal, ? extends Collection&lt;Principal&gt;&gt;, boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Blocking call to push group definitions to GSA ends in success or
 when default error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushGroupDefinitions(java.util.Map, boolean, com.google.enterprise.adaptor.ExceptionHandler)"><B>pushGroupDefinitions(Map&lt;GroupPrincipal, ? extends Collection&lt;Principal&gt;&gt;, boolean, ExceptionHandler)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Blocking call to push group definitions to GSA ends in success or
 when provided error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushNamedResources(java.util.Map)"><B>pushNamedResources(Map&lt;DocId, Acl&gt;)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Push named resources immediately and block until they are successfully
 provided to the GSA or the error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushNamedResources(java.util.Map, com.google.enterprise.adaptor.ExceptionHandler)"><B>pushNamedResources(Map&lt;DocId, Acl&gt;, ExceptionHandler)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Push named resources immediately and block until they are successfully
 provided to the GSA or the error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushRecords(java.lang.Iterable)"><B>pushRecords(Iterable&lt;DocIdPusher.Record&gt;)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Push <code>Record</code>s immediately and block until they are successfully
 provided to the GSA or the error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.html#pushRecords(java.lang.Iterable, com.google.enterprise.adaptor.ExceptionHandler)"><B>pushRecords(Iterable&lt;DocIdPusher.Record&gt;, ExceptionHandler)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor">DocIdPusher</A>
<DD>Push <code>Record</code>s immediately and block until they are successfully
 provided to the GSA or the error handler gives up.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#putNamedResource(java.lang.String, com.google.enterprise.adaptor.Acl)"><B>putNamedResource(String, Acl)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Provide alternative ACLs for this document, uniquely identified by
 response document's <code>DocId</code> and <code>fragment</code>.
</DL>
<HR>
<A NAME="_R_"><!-- --></A><H2>
<B>R</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html#readFromAuthorizer()"><B>readFromAuthorizer()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html" title="class in com.google.enterprise.adaptor">CommandStreamParser</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html#readFromLister(com.google.enterprise.adaptor.DocIdPusher, com.google.enterprise.adaptor.ExceptionHandler)"><B>readFromLister(DocIdPusher, ExceptionHandler)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html" title="class in com.google.enterprise.adaptor">CommandStreamParser</A>
<DD>Parse a listing response, sending results to <code>pusher</code>.
<DT><A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html#readFromRetriever(com.google.enterprise.adaptor.DocId, com.google.enterprise.adaptor.Response)"><B>readFromRetriever(DocId, Response)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.html" title="class in com.google.enterprise.adaptor">CommandStreamParser</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/IOHelper.html#readFully(java.io.InputStream, byte[], int, int)"><B>readFully(InputStream, byte[], int, int)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/IOHelper.html" title="class in com.google.enterprise.adaptor">IOHelper</A>
<DD>Reads a specified number of bytes from a stream.
<DT><A HREF="./com/google/enterprise/adaptor/IOHelper.html#readInputStreamToByteArray(java.io.InputStream)"><B>readInputStreamToByteArray(InputStream)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/IOHelper.html" title="class in com.google.enterprise.adaptor">IOHelper</A>
<DD>Read the contents of <code>is</code> into a byte array.
<DT><A HREF="./com/google/enterprise/adaptor/IOHelper.html#readInputStreamToString(java.io.InputStream, java.nio.charset.Charset)"><B>readInputStreamToString(InputStream, Charset)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/IOHelper.html" title="class in com.google.enterprise.adaptor">IOHelper</A>
<DD>Form a string from the contents of <code>is</code> with charset <code>charset</code>.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>RecursiveFileIterator</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Iterate over all files within a folder, including files in subdirectories.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html#RecursiveFileIterator(java.io.File)"><B>RecursiveFileIterator(File)</B></A> - 
Constructor for class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html" title="class in com.google.enterprise.adaptor.prebuilt">RecursiveFileIterator</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.WrappedIOException.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>RecursiveFileIterator.WrappedIOException</B></A> - Exception in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Allows throwing IOExceptions and allowing the caller to unpack and rethrow
 them with certainty.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.WrappedIOException.html#RecursiveFileIterator.WrappedIOException(java.io.IOException)"><B>RecursiveFileIterator.WrappedIOException(IOException)</B></A> - 
Constructor for exception com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.WrappedIOException.html" title="class in com.google.enterprise.adaptor.prebuilt">RecursiveFileIterator.WrappedIOException</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html#remove()"><B>remove()</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/RecursiveFileIterator.html" title="class in com.google.enterprise.adaptor.prebuilt">RecursiveFileIterator</A>
<DD>Unsupported.
<DT><A HREF="./com/google/enterprise/adaptor/Session.html#removeAttribute(java.lang.String)"><B>removeAttribute(String)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Session.html" title="interface in com.google.enterprise.adaptor">Session</A>
<DD>Remove attribute value.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html#replaceMetadata(java.util.Map)"><B>replaceMetadata(Map&lt;String, String&gt;)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/PrebuiltTransforms.html" title="class in com.google.enterprise.adaptor.prebuilt">PrebuiltTransforms</A>
<DD>Returns a transform that preforms string replacements within metadata
 values.
<DT><A HREF="./com/google/enterprise/adaptor/Request.html" title="interface in com.google.enterprise.adaptor"><B>Request</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface provided to <A HREF="./com/google/enterprise/adaptor/Adaptor.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><CODE>Adaptor.getDocContent(Request, Response)</CODE></A> for describing the action that
 should be taken.<DT><A HREF="./com/google/enterprise/adaptor/Response.html#respondNotFound()"><B>respondNotFound()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Respond to the GSA or other client that the request document does not
 exist.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#respondNotModified()"><B>respondNotModified()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Respond to the GSA or other client that it already has the latest version
 of a file and its metadata.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor"><B>Response</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface provided to <A HREF="./com/google/enterprise/adaptor/Adaptor.html#getDocContent(com.google.enterprise.adaptor.Request, com.google.enterprise.adaptor.Response)"><CODE>Adaptor.getDocContent(Request, Response)</CODE></A> for performing the actions needed
 to satisfy a request.<DT><A HREF="./com/google/enterprise/adaptor/Acl.BatchRetriever.html#retrieveAcls(java.util.Set)"><B>retrieveAcls(Set&lt;DocId&gt;)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.BatchRetriever.html" title="interface in com.google.enterprise.adaptor">Acl.BatchRetriever</A>
<DD>Retrieve the ACLs for the requested DocIds.
<DT><A HREF="./com/google/enterprise/adaptor/StatusSource.html#retrieveStatus()"><B>retrieveStatus()</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/StatusSource.html" title="interface in com.google.enterprise.adaptor">StatusSource</A>
<DD>Retrieve the current status.
<DT><A HREF="./com/google/enterprise/adaptor/experimental/Sim.html#run()"><B>run()</B></A> - 
Method in class com.google.enterprise.adaptor.experimental.<A HREF="./com/google/enterprise/adaptor/experimental/Sim.html" title="class in com.google.enterprise.adaptor.experimental">Sim</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_S_"><!-- --></A><H2>
<B>S</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html#sendRedirect(com.sun.net.httpserver.HttpExchange, java.net.URI)"><B>sendRedirect(HttpExchange, URI)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor">HttpExchanges</A>
<DD>Redirect client to <code>location</code>.
<DT><A HREF="./com/google/enterprise/adaptor/SensitiveValueDecoder.html" title="interface in com.google.enterprise.adaptor"><B>SensitiveValueDecoder</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Provides parsing of sensitive values that can be plain text, obfuscated, or
 encrypted.<DT><A HREF="./com/google/enterprise/adaptor/Session.html" title="interface in com.google.enterprise.adaptor"><B>Session</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Generic session-state container, but intended for authn bookkeeping.<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#set(java.lang.String, java.lang.String)"><B>set(String, String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Make v be only value associated with key.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#set(java.lang.String, java.util.Set)"><B>set(String, Set&lt;String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Make copy of v be the values associated with key.
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#set(java.lang.Iterable)"><B>set(Iterable&lt;Map.Entry&lt;String, String&gt;&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Replaces entries inside of this metadata with provided ones.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setAcl(com.google.enterprise.adaptor.Acl)"><B>setAcl(Acl)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Provide the document's ACLs for early-binding security on the GSA.
<DT><A HREF="./com/google/enterprise/adaptor/Session.html#setAttribute(java.lang.String, java.lang.Object)"><B>setAttribute(String, Object)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Session.html" title="interface in com.google.enterprise.adaptor">Session</A>
<DD>Set attribute value, replacing existing value if it already exists.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#setAuthnAuthority(com.google.enterprise.adaptor.AuthnAuthority)"><B>setAuthnAuthority(AuthnAuthority)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Register an authentication provider, so it can authenticate users for the
 GSA.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#setAuthzAuthority(com.google.enterprise.adaptor.AuthzAuthority)"><B>setAuthzAuthority(AuthzAuthority)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Register an authorization provider, so it can check authorization of users
 for the GSA.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#setCommandAcceptsParameters(boolean)"><B>setCommandAcceptsParameters(boolean)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>This controls whether the input parameters to the transform call are passed
 along to the actual call to the command.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setContentType(java.lang.String)"><B>setContentType(String)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Describe the content type of the document.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#setCrawlImmediately(boolean)"><B>setCrawlImmediately(boolean)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Inform the GSA that the document has been modified, and that the GSA
 should give high priority to recrawling the document.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#setCrawlOnce(boolean)"><B>setCrawlOnce(boolean)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Instruct the GSA to not recrawl the document after the initial
 retrieval.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setCrawlOnce(boolean)"><B>setCrawlOnce(boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Instruct the GSA to not recrawl the document after the initial
 retrieval.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#setDeleteFromIndex(boolean)"><B>setDeleteFromIndex(boolean)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Set whether the GSA is being informed the document has been deleted.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setDenies(java.util.Collection)"><B>setDenies(Collection&lt;Principal&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Replace existing deny users and groups.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setDenyGroups(java.util.Collection)"><B>setDenyGroups(Collection&lt;GroupPrincipal&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Replace existing deny groups.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setDenyUsers(java.util.Collection)"><B>setDenyUsers(Collection&lt;UserPrincipal&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Replace existing deny users.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setDisplayUrl(java.net.URI)"><B>setDisplayUrl(URI)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Set the URI to be displayed in search results.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#setDocId(com.google.enterprise.adaptor.DocId)"><B>setDocId(DocId)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Set the identifier for the document this record is providing
 information for.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setEverythingCaseInsensitive()"><B>setEverythingCaseInsensitive()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setEverythingCaseSensitive()"><B>setEverythingCaseSensitive()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#setGetDocIdsFullErrorHandler(com.google.enterprise.adaptor.ExceptionHandler)"><B>setGetDocIdsFullErrorHandler(ExceptionHandler)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Override the default <A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html" title="interface in com.google.enterprise.adaptor"><CODE>ExceptionHandler</CODE></A> for full push.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#setGetDocIdsIncrementalErrorHandler(com.google.enterprise.adaptor.ExceptionHandler)"><B>setGetDocIdsIncrementalErrorHandler(ExceptionHandler)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Override the default <A HREF="./com/google/enterprise/adaptor/ExceptionHandler.html" title="interface in com.google.enterprise.adaptor"><CODE>ExceptionHandler</CODE></A> for incremental push.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setInheritanceType(com.google.enterprise.adaptor.Acl.InheritanceType)"><B>setInheritanceType(Acl.InheritanceType)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Set the type of inheritance of ACL information used to combine authz
 decisions of these ACLs with its <em>child</em>.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setInheritFrom(com.google.enterprise.adaptor.DocId)"><B>setInheritFrom(DocId)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Set <code>DocId</code> to inherit ACLs from.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setInheritFrom(com.google.enterprise.adaptor.DocId, java.lang.String)"><B>setInheritFrom(DocId, String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Set the parent to inherit ACLs from.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#setLastModified(java.util.Date)"><B>setLastModified(Date)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Provides the last-modified date of the document.
<DT><A HREF="./com/google/enterprise/adaptor/HttpExchanges.html#setLastModified(com.sun.net.httpserver.HttpExchange, java.util.Date)"><B>setLastModified(HttpExchange, Date)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/HttpExchanges.html" title="class in com.google.enterprise.adaptor">HttpExchanges</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setLastModified(java.util.Date)"><B>setLastModified(Date)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Provide the last modification time of the document.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#setListerCommand(java.util.List)"><B>setListerCommand(List&lt;String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#setLock(boolean)"><B>setLock(boolean)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Instruct the GSA to "lock" the document into its index.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setLock(boolean)"><B>setLock(boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Instruct the GSA to "lock" the document into its index.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setNoArchive(boolean)"><B>setNoArchive(boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Whether the GSA should show the "Cached" link in search results for this
 document.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setNoFollow(boolean)"><B>setNoFollow(boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Whether the GSA should follow the links within the document to find other
 documents.
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setNoIndex(boolean)"><B>setNoIndex(boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Whether the GSA should index the content for searching.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setPermitGroups(java.util.Collection)"><B>setPermitGroups(Collection&lt;GroupPrincipal&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Replace existing permit groups.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setPermits(java.util.Collection)"><B>setPermits(Collection&lt;Principal&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Replace existing permit users and groups.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.Builder.html#setPermitUsers(java.util.Collection)"><B>setPermitUsers(Collection&lt;UserPrincipal&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.Builder.html" title="class in com.google.enterprise.adaptor">Acl.Builder</A>
<DD>Replace existing permit users.
<DT><A HREF="./com/google/enterprise/adaptor/AdaptorContext.html#setPollingIncrementalLister(com.google.enterprise.adaptor.PollingIncrementalLister)"><B>setPollingIncrementalLister(PollingIncrementalLister)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AdaptorContext.html" title="interface in com.google.enterprise.adaptor">AdaptorContext</A>
<DD>Register a polling incremental lister, so that it can be called when
 appropriate.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html#setResultLink(java.net.URI)"><B>setResultLink(URI)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.Builder.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record.Builder</A>
<DD>Set the URI to be displayed to the user in search results.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#setRetrieverCommand(java.util.List)"><B>setRetrieverCommand(List&lt;String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineAdaptor</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Response.html#setSecure(boolean)"><B>setSecure(boolean)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Response.html" title="interface in com.google.enterprise.adaptor">Response</A>
<DD>Mark the document as secure, for use with late-binding security.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#setTransformCommand(java.util.List)"><B>setTransformCommand(List&lt;String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>Sets the command that is in charge of transforming the document content.
<DT><A HREF="./com/google/enterprise/adaptor/CustomFormatter.html#setUseColor(boolean)"><B>setUseColor(boolean)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CustomFormatter.html" title="class in com.google.enterprise.adaptor">CustomFormatter</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#setWorkingDirectory(java.io.File)"><B>setWorkingDirectory(File)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>Sets the working directory.
<DT><A HREF="./com/google/enterprise/adaptor/experimental/Sim.html" title="class in com.google.enterprise.adaptor.experimental"><B>Sim</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/experimental/package-summary.html">com.google.enterprise.adaptor.experimental</A><DD>Accepts adaptor feeds and issues requests for documents.<DT><A HREF="./com/google/enterprise/adaptor/experimental/Sim.html#Sim()"><B>Sim()</B></A> - 
Constructor for class com.google.enterprise.adaptor.experimental.<A HREF="./com/google/enterprise/adaptor/experimental/Sim.html" title="class in com.google.enterprise.adaptor.experimental">Sim</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.OutputSink.html#sink(java.io.InputStream)"><B>sink(InputStream)</B></A> - 
Method in interface com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.OutputSink.html" title="interface in com.google.enterprise.adaptor.prebuilt">StreamingCommand.OutputSink</A>
<DD>Consume content from <code>in</code>.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.InputSource.html#source(java.io.OutputStream)"><B>source(OutputStream)</B></A> - 
Method in interface com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.InputSource.html" title="interface in com.google.enterprise.adaptor.prebuilt">StreamingCommand.InputSource</A>
<DD>Generate content and write it to <code>out</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Application.html#start()"><B>start()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Application.html" title="class in com.google.enterprise.adaptor">Application</A>
<DD>Start necessary services for receiving requests and managing background
 tasks.
<DT><A HREF="./com/google/enterprise/adaptor/Daemon.html#start()"><B>start()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Daemon.html" title="class in com.google.enterprise.adaptor">Daemon</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#start(com.sun.net.httpserver.HttpServer, com.sun.net.httpserver.HttpServer)"><B>start(HttpServer, HttpServer)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor">GsaCommunicationHandler</A>
<DD>Starts listening for communications from GSA.
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#start(com.sun.net.httpserver.HttpServer, com.sun.net.httpserver.HttpServer, java.lang.String)"><B>start(HttpServer, HttpServer, String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor">GsaCommunicationHandler</A>
<DD>Starts listening for communications from GSA.
<DT><A HREF="./com/google/enterprise/adaptor/Status.html" title="interface in com.google.enterprise.adaptor"><B>Status</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Multi-state indicator providing the user with a notification of broken parts
 of the system.<DT><A HREF="./com/google/enterprise/adaptor/Status.Code.html" title="enum in com.google.enterprise.adaptor"><B>Status.Code</B></A> - Enum in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Available statuses for displaying state indicators on the dashboard.<DT><A HREF="./com/google/enterprise/adaptor/StatusSource.html" title="interface in com.google.enterprise.adaptor"><B>StatusSource</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>A source of <A HREF="./com/google/enterprise/adaptor/Status.html" title="interface in com.google.enterprise.adaptor"><CODE>Status</CODE></A> messages.<DT><A HREF="./com/google/enterprise/adaptor/Application.html#stop(long, java.util.concurrent.TimeUnit)"><B>stop(long, TimeUnit)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Application.html" title="class in com.google.enterprise.adaptor">Application</A>
<DD>Stop processing incoming requests and background tasks, allowing graceful
 shutdown.
<DT><A HREF="./com/google/enterprise/adaptor/Daemon.html#stop()"><B>stop()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Daemon.html" title="class in com.google.enterprise.adaptor">Daemon</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#stop(long, java.util.concurrent.TimeUnit)"><B>stop(long, TimeUnit)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html" title="class in com.google.enterprise.adaptor">GsaCommunicationHandler</A>
<DD>Stop the current services, allowing up to <code>maxDelay</code> seconds for
 things to shutdown.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>StreamingCommand</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Exec helper that allows easy handling of stdin, stdout, and stderr.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.InputSource.html" title="interface in com.google.enterprise.adaptor.prebuilt"><B>StreamingCommand.InputSource</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Content source that generates content at the rate it can be consumed.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.OutputSink.html" title="interface in com.google.enterprise.adaptor.prebuilt"><B>StreamingCommand.OutputSink</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</A><DD>Content sink that consumes content as soon as it becomes available.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html#streamInputSource(java.io.InputStream)"><B>streamInputSource(InputStream)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand</A>
<DD><A HREF="http://download.oracle.com/javase/6/docs/api/java/io/InputStream.html?is-external=true" title="class or interface in java.io"><CODE>InputStream</CODE></A> to <A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.InputSource.html" title="interface in com.google.enterprise.adaptor.prebuilt"><CODE>StreamingCommand.InputSource</CODE></A> adaptor.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html#streamOutputSink(java.io.OutputStream)"><B>streamOutputSink(OutputStream)</B></A> - 
Static method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand</A>
<DD><A HREF="http://download.oracle.com/javase/6/docs/api/java/io/OutputStream.html?is-external=true" title="class or interface in java.io"><CODE>OutputStream</CODE></A> to <A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.OutputSink.html" title="interface in com.google.enterprise.adaptor.prebuilt"><CODE>StreamingCommand.OutputSink</CODE></A> adaptor.
</DL>
<HR>
<A NAME="_T_"><!-- --></A><H2>
<B>T</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#toString()"><B>toString()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.html" title="class in com.google.enterprise.adaptor">Acl</A>
<DD>Generates a string useful for debugging that contains users and groups
 along with inheritance information.
<DT><A HREF="./com/google/enterprise/adaptor/DocId.html#toString()"><B>toString()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocId.html" title="class in com.google.enterprise.adaptor">DocId</A>
<DD>Generates a string useful for debugging that contains the unique id.
<DT><A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html#toString()"><B>toString()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocIdPusher.Record.html" title="class in com.google.enterprise.adaptor">DocIdPusher.Record</A>
<DD>Generates a string representation of this instance useful for debugging
 that contains all visible fields.
<DT><A HREF="./com/google/enterprise/adaptor/examples/MetadataTransformExample.html#toString()"><B>toString()</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/MetadataTransformExample.html" title="class in com.google.enterprise.adaptor.examples">MetadataTransformExample</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#toString()"><B>toString()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Contains every key and value pair; useful for debugging.
<DT><A HREF="./com/google/enterprise/adaptor/Principal.html#toString()"><B>toString()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Principal.html" title="class in com.google.enterprise.adaptor">Principal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocumentTransform.html#transform(com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(Metadata, Map&lt;String, String&gt;)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DocumentTransform.html" title="interface in com.google.enterprise.adaptor">DocumentTransform</A>
<DD>Any changes to <code>metadata</code> and <code>params</code> will be
 passed on to subsequent transforms.
<DT><A HREF="./com/google/enterprise/adaptor/examples/MetadataTransformExample.html#transform(com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(Metadata, Map&lt;String, String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/MetadataTransformExample.html" title="class in com.google.enterprise.adaptor.examples">MetadataTransformExample</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#transform(com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(Metadata, Map&lt;String, String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html" title="class in com.google.enterprise.adaptor.prebuilt">CommandLineTransform</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_U_"><!-- --></A><H2>
<B>U</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Metadata.html#unmodifiableView()"><B>unmodifiableView()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Metadata.html" title="class in com.google.enterprise.adaptor">Metadata</A>
<DD>Get a reference to an unmodifiable view of this object.
<DT><A HREF="./com/google/enterprise/adaptor/AuthnAuthority.Callback.html#userAuthenticated(com.sun.net.httpserver.HttpExchange, com.google.enterprise.adaptor.AuthnIdentity)"><B>userAuthenticated(HttpExchange, AuthnIdentity)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthnAuthority.Callback.html" title="interface in com.google.enterprise.adaptor">AuthnAuthority.Callback</A>
<DD>Respond with authentication information discovered during <A HREF="./com/google/enterprise/adaptor/AuthnAuthority.html#authenticateUser(com.sun.net.httpserver.HttpExchange, com.google.enterprise.adaptor.AuthnAuthority.Callback)"><CODE>AuthnAdaptor.authenticateUser(HttpExchange, Callback)</CODE></A>.
<DT><A HREF="./com/google/enterprise/adaptor/UserPrincipal.html" title="class in com.google.enterprise.adaptor"><B>UserPrincipal</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Represents user.<DT><A HREF="./com/google/enterprise/adaptor/UserPrincipal.html#UserPrincipal(java.lang.String, java.lang.String)"><B>UserPrincipal(String, String)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/UserPrincipal.html" title="class in com.google.enterprise.adaptor">UserPrincipal</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/UserPrincipal.html#UserPrincipal(java.lang.String)"><B>UserPrincipal(String)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/UserPrincipal.html" title="class in com.google.enterprise.adaptor">UserPrincipal</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_V_"><!-- --></A><H2>
<B>V</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#validate()"><B>validate()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Config.html" title="class in com.google.enterprise.adaptor">Config</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/Acl.InheritanceType.html#valueOf(java.lang.String)"><B>valueOf(String)</B></A> - 
Static method in enum com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.InheritanceType.html" title="enum in com.google.enterprise.adaptor">Acl.InheritanceType</A>
<DD>Returns the enum constant of this type with the specified name.
<DT><A HREF="./com/google/enterprise/adaptor/AuthzStatus.html#valueOf(java.lang.String)"><B>valueOf(String)</B></A> - 
Static method in enum com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthzStatus.html" title="enum in com.google.enterprise.adaptor">AuthzStatus</A>
<DD>Returns the enum constant of this type with the specified name.
<DT><A HREF="./com/google/enterprise/adaptor/Status.Code.html#valueOf(java.lang.String)"><B>valueOf(String)</B></A> - 
Static method in enum com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Status.Code.html" title="enum in com.google.enterprise.adaptor">Status.Code</A>
<DD>Returns the enum constant of this type with the specified name.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.InheritanceType.html#values()"><B>values()</B></A> - 
Static method in enum com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Acl.InheritanceType.html" title="enum in com.google.enterprise.adaptor">Acl.InheritanceType</A>
<DD>Returns an array containing the constants of this enum type, in
the order they are declared.
<DT><A HREF="./com/google/enterprise/adaptor/AuthzStatus.html#values()"><B>values()</B></A> - 
Static method in enum com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AuthzStatus.html" title="enum in com.google.enterprise.adaptor">AuthzStatus</A>
<DD>Returns an array containing the constants of this enum type, in
the order they are declared.
<DT><A HREF="./com/google/enterprise/adaptor/Status.Code.html#values()"><B>values()</B></A> - 
Static method in enum com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/Status.Code.html" title="enum in com.google.enterprise.adaptor">Status.Code</A>
<DD>Returns an array containing the constants of this enum type, in
the order they are declared.
</DL>
<HR>
<A NAME="_W_"><!-- --></A><H2>
<B>W</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/IOHelper.html#writeToTempFile(java.io.InputStream)"><B>writeToTempFile(InputStream)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/IOHelper.html" title="class in com.google.enterprise.adaptor">IOHelper</A>
<DD>Write contents of <code>in</code> to a temporary file.
<DT><A HREF="./com/google/enterprise/adaptor/IOHelper.html#writeToTempFile(java.lang.String, java.nio.charset.Charset)"><B>writeToTempFile(String, Charset)</B></A> - 
Static method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/IOHelper.html" title="class in com.google.enterprise.adaptor">IOHelper</A>
<DD>Write contents of <code>string</code> to a temporary file, encoded using <code>charset</code>.
</DL>
<HR>
<A HREF="#_A_">A</A> <A HREF="#_B_">B</A> <A HREF="#_C_">C</A> <A HREF="#_D_">D</A> <A HREF="#_E_">E</A> <A HREF="#_F_">F</A> <A HREF="#_G_">G</A> <A HREF="#_H_">H</A> <A HREF="#_I_">I</A> <A HREF="#_L_">L</A> <A HREF="#_M_">M</A> <A HREF="#_N_">N</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_R_">R</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_U_">U</A> <A HREF="#_V_">V</A> <A HREF="#_W_">W</A> 

<!-- ======= START OF BOTTOM NAVBAR ====== -->
<A NAME="navbar_bottom"><!-- --></A>
<A HREF="#skip-navbar_bottom" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_bottom_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_bottom"></A>
<!-- ======== END OF BOTTOM NAVBAR ======= -->

<HR>

</BODY>
</HTML>
