<!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/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor"><B>AbstractDocumentTransform</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Convenience class for implementing <code>DocumentTransform</code>s.<DT><A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html#AbstractDocumentTransform()"><B>AbstractDocumentTransform()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor">AbstractDocumentTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html#AbstractDocumentTransform(java.lang.String, boolean)"><B>AbstractDocumentTransform(String, boolean)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor">AbstractDocumentTransform</A>
<DD>If <code>name</code> is <code>null</code>, the default is used.
<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/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/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.<DT><A HREF="./com/google/enterprise/adaptor/Config.html#autoConfig(java.lang.String[])"><B>autoConfig(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 default configuration file and parse command line options.
</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/examples/CalaisNERTransform.html" title="class in com.google.enterprise.adaptor.examples"><B>CalaisNERTransform</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>This transform sends the content to the OpenCalais webservice, which
 extracts named entities.<DT><A HREF="./com/google/enterprise/adaptor/examples/CalaisNERTransform.html#CalaisNERTransform()"><B>CalaisNERTransform()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/CalaisNERTransform.html" title="class in com.google.enterprise.adaptor.examples">CalaisNERTransform</A>
<DD>&nbsp;
<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/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/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.html#Command()"><B>Command()</B></A> - 
Constructor for 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>&nbsp;
<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/CommandStreamParser.RetrieverInfo.html" title="class in com.google.enterprise.adaptor"><B>CommandStreamParser.RetrieverInfo</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</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/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/AbstractDocumentTransform.html#configure(java.util.Map)"><B>configure(Map&lt;String, String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor">AbstractDocumentTransform</A>
<DD>Configure this instance with provided <code>config</code>.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#configure(java.util.Map)"><B>configure(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>Accepts keys <code>"cmd"</code>, <code>"workingDirectory"</code>, <code>"arg?"</code>, and
 any keys accepted by the super class.
<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/CalaisNERTransform.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/CalaisNERTransform.html" title="class in com.google.enterprise.adaptor.examples">CalaisNERTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/MetaTaggerTransform.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/MetaTaggerTransform.html" title="class in com.google.enterprise.adaptor.examples">MetaTaggerTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.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/TableGeneratorTransform.html" title="class in com.google.enterprise.adaptor.examples">TableGeneratorTransform</A>
<DD>&nbsp;
<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>&nbsp;
<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/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/DefaultGetDocIdsErrorHandler.html" title="class in com.google.enterprise.adaptor"><B>DefaultGetDocIdsErrorHandler</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Default handler of errors during <A HREF="./com/google/enterprise/adaptor/Adaptor.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><CODE>Adaptor.getDocIds(DocIdPusher)</CODE></A>.<DT><A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html#DefaultGetDocIdsErrorHandler()"><B>DefaultGetDocIdsErrorHandler()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultGetDocIdsErrorHandler</A>
<DD>Same as <code>DefaultGetDocIdsErrorHandler(12, 5000)</code>.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html#DefaultGetDocIdsErrorHandler(int, long)"><B>DefaultGetDocIdsErrorHandler(int, long)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultGetDocIdsErrorHandler</A>
<DD>Create a default error handler that gives up after <code>maximumTries</code> and
 sleeps <code>sleepTimeMillis * numberOfTries</code> before retrying.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html" title="class in com.google.enterprise.adaptor"><B>DefaultPushErrorHandler</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Default handler of errors during a push of <code>DocId</code>s to the GSA.<DT><A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html#DefaultPushErrorHandler()"><B>DefaultPushErrorHandler()</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultPushErrorHandler</A>
<DD>Same as <code>DefaultPushErrorHandler(12, 5000)</code>.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html#DefaultPushErrorHandler(int, long)"><B>DefaultPushErrorHandler(int, long)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultPushErrorHandler</A>
<DD>Create a default error handler that gives up after <code>maximumTries</code> and
 sleeps <code>sleepTimeMillis * numberOfTries</code> before retrying.
<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/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/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/prebuilt/Command.html#exec(java.lang.String[])"><B>exec(String[])</B></A> - 
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> - 
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> - 
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> - 
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.
</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/prebuilt/CommandLineAdaptor.html#geRetrieverCommand()"><B>geRetrieverCommand()</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#getAdaptorFullListingSchedule()"><B>getAdaptorFullListingSchedule()</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>Cron-style format for describing when the adaptor should perform full
 listings of <code>DocId</code>s.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getAdaptorIncrementalPollPeriodMillis()"><B>getAdaptorIncrementalPollPeriodMillis()</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/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/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/CommandStreamParser.RetrieverInfo.html#getContents()"><B>getContents()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.RetrieverInfo.html" title="class in com.google.enterprise.adaptor">CommandStreamParser.RetrieverInfo</A>
<DD>&nbsp;
<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/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/CommandStreamParser.RetrieverInfo.html#getDocId()"><B>getDocId()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.RetrieverInfo.html" title="class in com.google.enterprise.adaptor">CommandStreamParser.RetrieverInfo</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/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/GetDocIdsErrorHandler.html" title="interface in com.google.enterprise.adaptor"><B>GetDocIdsErrorHandler</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for handling errors encountered during scheduled pushing of <code>DocId</code>s.<DT><A HREF="./com/google/enterprise/adaptor/TransformPipeline.html#getDocumentTransforms()"><B>getDocumentTransforms()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/TransformPipeline.html" title="class in com.google.enterprise.adaptor">TransformPipeline</A>
<DD>Retrieve transforms in the order they are processed in the pipeline.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getFeedMaxUrls()"><B>getFeedMaxUrls()</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>Provides max number of URLs (equal to number of document ids) that are sent
 to the GSA per feed file.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getFeedName()"><B>getFeedName()</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/AdaptorContext.html#getGetDocIdsErrorHandler()"><B>getGetDocIdsErrorHandler()</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/GetDocIdsErrorHandler.html" title="interface in com.google.enterprise.adaptor"><CODE>GetDocIdsErrorHandler</CODE></A>.
<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/Config.html#getGsaCharacterEncoding()"><B>getGsaCharacterEncoding()</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>Provides the character encoding the GSA prefers.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getGsaHostname()"><B>getGsaHostname()</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>Required to be set: GSA machine to send document ids to.
<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/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/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/CommandStreamParser.RetrieverInfo.html#getMetadata()"><B>getMetadata()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.RetrieverInfo.html" title="class in com.google.enterprise.adaptor">CommandStreamParser.RetrieverInfo</A>
<DD>Returns unmodifiable view of Metadata.
<DT><A HREF="./com/google/enterprise/adaptor/CommandStreamParser.RetrieverInfo.html#getMimeType()"><B>getMimeType()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.RetrieverInfo.html" title="class in com.google.enterprise.adaptor">CommandStreamParser.RetrieverInfo</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/PollingIncrementalAdaptor.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/PollingIncrementalAdaptor.html" title="interface in com.google.enterprise.adaptor">PollingIncrementalAdaptor</A>
<DD>Check for documents modified since the last call to the method.
<DT><A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html#getName()"><B>getName()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor">AbstractDocumentTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocumentTransform.html#getName()"><B>getName()</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>The name of this transform instance, typically provided by the user.
<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/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#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/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/Command.html#getReturnCode()"><B>getReturnCode()</B></A> - 
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>&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/Config.html#getServerBaseUri()"><B>getServerBaseUri()</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>Optional: Returns this host's base URI which other paths will be resolved
 against.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerBaseUri(com.google.enterprise.adaptor.DocId)"><B>getServerBaseUri(DocId)</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>Optional: Returns the host's base URI which GSA will contact for document
 information, including document contents.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerDashboardPort()"><B>getServerDashboardPort()</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>Local port, on this computer, from which the dashboard is served.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerDocIdPath()"><B>getServerDocIdPath()</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>Optional: Path below <A HREF="./com/google/enterprise/adaptor/Config.html#getServerBaseUri(com.google.enterprise.adaptor.DocId)"><CODE>Config.getServerBaseUri(DocId)</CODE></A> where documents are
 namespaced.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerFullAccessHosts()"><B>getServerFullAccessHosts()</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>Comma-separated list of IPs or hostnames that can retrieve content without
 authentication checks.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerHostname()"><B>getServerHostname()</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>Without changes contains InetAddress.getLocalHost().getHostName().
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerKeyAlias()"><B>getServerKeyAlias()</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>The alias in the keystore that has the key to use for encryption.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerMaxWorkerThreads()"><B>getServerMaxWorkerThreads()</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>The maximum number of worker threads to use to respond to document
 requests.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerPort()"><B>getServerPort()</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>Suggested to be set: Local port, on this computer, onto which requests from
 GSA come in on.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerQueueCapacity()"><B>getServerQueueCapacity()</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>The maximum request queue length.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerReverseProxyPort()"><B>getServerReverseProxyPort()</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>The port that should be used in feed file and other references to the
 adaptor.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#getServerReverseProxyProtocol()"><B>getServerReverseProxyProtocol()</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>The protocol that should be used in feed files and other references to the
 adaptor.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html#getStderr()"><B>getStderr()</B></A> - 
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>Returns internal byte array without copying.
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/Command.html#getStdout()"><B>getStdout()</B></A> - 
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>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/Config.html#getTransformMaxDocumentBytes()"><B>getTransformMaxDocumentBytes()</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/Config.html#getTransformPipelineSpec()"><B>getTransformPipelineSpec()</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 correspending to each transform in the pipeline.
<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#getUsername()"><B>getUsername()</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 identifier.
<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.
<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/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/DefaultPushErrorHandler.html#handleFailedReadingReply(java.lang.Exception, int)"><B>handleFailedReadingReply(Exception, int)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultPushErrorHandler</A>
<DD>Handle a failure that <A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><CODE>DocIdPusher</CODE></A> had reading the GSA's response.
<DT><A HREF="./com/google/enterprise/adaptor/PushErrorHandler.html#handleFailedReadingReply(java.lang.Exception, int)"><B>handleFailedReadingReply(Exception, int)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/PushErrorHandler.html" title="interface in com.google.enterprise.adaptor">PushErrorHandler</A>
<DD>Handle a failure that <A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><CODE>DocIdPusher</CODE></A> had reading the GSA's response.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html#handleFailedToConnect(java.lang.Exception, int)"><B>handleFailedToConnect(Exception, int)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultPushErrorHandler</A>
<DD>Handle a failure that <A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><CODE>DocIdPusher</CODE></A> had connecting with the GSA to
 send a batch.
<DT><A HREF="./com/google/enterprise/adaptor/PushErrorHandler.html#handleFailedToConnect(java.lang.Exception, int)"><B>handleFailedToConnect(Exception, int)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/PushErrorHandler.html" title="interface in com.google.enterprise.adaptor">PushErrorHandler</A>
<DD>Handle a failure that <A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><CODE>DocIdPusher</CODE></A> had connecting with the GSA to
 send a batch.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html#handleFailedToGetDocIds(java.lang.Exception, int)"><B>handleFailedToGetDocIds(Exception, int)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultGetDocIdsErrorHandler</A>
<DD>There was a failure running <A HREF="./com/google/enterprise/adaptor/Adaptor.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><CODE>Adaptor.getDocIds(com.google.enterprise.adaptor.DocIdPusher)</CODE></A>.
<DT><A HREF="./com/google/enterprise/adaptor/GetDocIdsErrorHandler.html#handleFailedToGetDocIds(java.lang.Exception, int)"><B>handleFailedToGetDocIds(Exception, int)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/GetDocIdsErrorHandler.html" title="interface in com.google.enterprise.adaptor">GetDocIdsErrorHandler</A>
<DD>There was a failure running <A HREF="./com/google/enterprise/adaptor/Adaptor.html#getDocIds(com.google.enterprise.adaptor.DocIdPusher)"><CODE>Adaptor.getDocIds(com.google.enterprise.adaptor.DocIdPusher)</CODE></A>.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html#handleFailedWriting(java.lang.Exception, int)"><B>handleFailedWriting(Exception, int)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultPushErrorHandler</A>
<DD>Handle a failure that <A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><CODE>DocIdPusher</CODE></A> had writing to the GSA while
 sending a batch.
<DT><A HREF="./com/google/enterprise/adaptor/PushErrorHandler.html#handleFailedWriting(java.lang.Exception, int)"><B>handleFailedWriting(Exception, int)</B></A> - 
Method in interface com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/PushErrorHandler.html" title="interface in com.google.enterprise.adaptor">PushErrorHandler</A>
<DD>Handle a failure that <A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><CODE>DocIdPusher</CODE></A> had writing to the GSA while
 sending a batch.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html#handleGeneric(java.lang.Exception, int)"><B>handleGeneric(Exception, int)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultGetDocIdsErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultGetDocIdsErrorHandler</A>
<DD>Common handle method for generic error handling.
<DT><A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html#handleGeneric(java.lang.Exception, int)"><B>handleGeneric(Exception, int)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/DefaultPushErrorHandler.html" title="class in com.google.enterprise.adaptor">DefaultPushErrorHandler</A>
<DD>Common handle method for generic error handling.
<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/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.
</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/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/Config.html#isAdaptorPushDocIdsOnStartup()"><B>isAdaptorPushDocIdsOnStartup()</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>Whether the default <code>main()</code> should automatically start pushing all
 document ids on startup.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#isAuthorized(java.lang.String, java.util.Collection, java.util.List)"><B>isAuthorized(String, Collection&lt;String&gt;, 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>userIdentifier</code> belonging to <code>groups</code> is authorized for the provided <code>aclChain</code>.
<DT><A HREF="./com/google/enterprise/adaptor/Acl.html#isAuthorizedBatch(java.lang.String, java.util.Collection, java.util.Collection, com.google.enterprise.adaptor.Acl.BatchRetriever)"><B>isAuthorizedBatch(String, Collection&lt;String&gt;, 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(java.lang.String, java.util.Collection)"><B>isAuthorizedLocal(String, Collection&lt;String&gt;)</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/Config.html#isCrawlImmediatelyBitEnabled()"><B>isCrawlImmediatelyBitEnabled()</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>Optional (default false): Adds crawl-immediately bit with sent records in
 feed file.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#isDocIdUrl()"><B>isDocIdUrl()</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>Optional (default false): If your DocIds are already valid URLs you can
 have this method return true and they will be sent to GSA unmodified.
<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/Config.html#isFeedNoRecrawlBitEnabled()"><B>isFeedNoRecrawlBitEnabled()</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>Optional (default false): Adds no-recrawl bit with sent records in feed
 file.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#isGsa614FeedWorkaroundEnabled()"><B>isGsa614FeedWorkaroundEnabled()</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/Config.html#isJournalReducedMem()"><B>isJournalReducedMem()</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/AbstractDocumentTransform.html#isRequired()"><B>isRequired()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor">AbstractDocumentTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/DocumentTransform.html#isRequired()"><B>isRequired()</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>If this property is true, a failure of this transform will cause the entire
 transform pipeline to abort.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#isServerSecure()"><B>isServerSecure()</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>Whether full security should be enabled.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#isServerToUseCompression()"><B>isServerToUseCompression()</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/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/Config.html#isTransformRequired()"><B>isTransformRequired()</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/CommandStreamParser.RetrieverInfo.html#isUpToDate()"><B>isUpToDate()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.RetrieverInfo.html" title="class in com.google.enterprise.adaptor">CommandStreamParser.RetrieverInfo</A>
<DD>&nbsp;
<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/AbstractAdaptor.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.<A HREF="./com/google/enterprise/adaptor/AbstractAdaptor.html" title="class in com.google.enterprise.adaptor">AbstractAdaptor</A>
<DD>Determines whether the user identified is allowed to access the <code>DocId</code>s.
<DT><A HREF="./com/google/enterprise/adaptor/Adaptor.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/Adaptor.html" title="interface in com.google.enterprise.adaptor">Adaptor</A>
<DD>Determines whether the user identified is allowed to access the <code>DocId</code>s.
<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.
<DT><A HREF="./com/google/enterprise/adaptor/Config.html#loadDefaultConfigFile()"><B>loadDefaultConfigFile()</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>Loads <code>adaptor-config.properties</code> in the current directory, if it
 exists.
</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/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/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/MetaTaggerTransform.html" title="class in com.google.enterprise.adaptor.examples"><B>MetaTaggerTransform</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>The transform examines the document for regex patterns.<DT><A HREF="./com/google/enterprise/adaptor/examples/MetaTaggerTransform.html#MetaTaggerTransform()"><B>MetaTaggerTransform()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/MetaTaggerTransform.html" title="class in com.google.enterprise.adaptor.examples">MetaTaggerTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/MetaTaggerTransform.html#MetaTaggerTransform(java.lang.String)"><B>MetaTaggerTransform(String)</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/MetaTaggerTransform.html" title="class in com.google.enterprise.adaptor.examples">MetaTaggerTransform</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_N_"><!-- --></A><H2>
<B>N</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineAdaptor.html#newAuthorizerCommand()"><B>newAuthorizerCommand()</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#newListerCommand()"><B>newListerCommand()</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#newRetrieverCommand()"><B>newRetrieverCommand()</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/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/CommandStreamParser.RetrieverInfo.html#notFound()"><B>notFound()</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/CommandStreamParser.RetrieverInfo.html" title="class in com.google.enterprise.adaptor">CommandStreamParser.RetrieverInfo</A>
<DD>&nbsp;
</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/PollingIncrementalAdaptor.html" title="interface in com.google.enterprise.adaptor"><B>PollingIncrementalAdaptor</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/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.PushErrorHandler)"><B>pushDocIds(Iterable&lt;DocId&gt;, PushErrorHandler)</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/PushErrorHandler.html" title="interface in com.google.enterprise.adaptor"><B>PushErrorHandler</B></A> - Interface in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Interface for handling errors encountered during pushing of <code>DocId</code>s
 via <A HREF="./com/google/enterprise/adaptor/DocIdPusher.html" title="interface in com.google.enterprise.adaptor"><CODE>DocIdPusher</CODE></A>.<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.PushErrorHandler)"><B>pushNamedResources(Map&lt;DocId, Acl&gt;, PushErrorHandler)</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.PushErrorHandler)"><B>pushRecords(Iterable&lt;DocIdPusher.Record&gt;, PushErrorHandler)</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.
</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()"><B>readFromLister()</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#readFromRetriever()"><B>readFromRetriever()</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/AdaptorContext.html#removeStatusSource(com.google.enterprise.adaptor.StatusSource)"><B>removeStatusSource(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>Remove a previously added status source to the dashboard.
<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.
</DL>
<HR>
<A NAME="_S_"><!-- --></A><H2>
<B>S</B></H2>
<DL>
<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/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/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/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#setDenyGroups(java.util.Collection)"><B>setDenyGroups(Collection&lt;String&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;String&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/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/AdaptorContext.html#setGetDocIdsErrorHandler(com.google.enterprise.adaptor.GetDocIdsErrorHandler)"><B>setGetDocIdsErrorHandler(GetDocIdsErrorHandler)</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/GetDocIdsErrorHandler.html" title="interface in com.google.enterprise.adaptor"><CODE>GetDocIdsErrorHandler</CODE></A>.
<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/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/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/AbstractDocumentTransform.html#setName(java.lang.String)"><B>setName(String)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor">AbstractDocumentTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#setName(java.lang.String)"><B>setName(String)</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/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;String&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#setPermitUsers(java.util.Collection)"><B>setPermitUsers(Collection&lt;String&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/AbstractDocumentTransform.html#setRequired(boolean)"><B>setRequired(boolean)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/AbstractDocumentTransform.html" title="class in com.google.enterprise.adaptor">AbstractDocumentTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#setRequired(boolean)"><B>setRequired(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>&nbsp;
<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/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.StreamOutputSink.html#sink(java.io.InputStream)"><B>sink(InputStream)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.StreamOutputSink.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand.StreamOutputSink</A>
<DD>&nbsp;
<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/prebuilt/StreamingCommand.StreamInputSource.html#source(java.io.OutputStream)"><B>source(OutputStream)</B></A> - 
Method in class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.StreamInputSource.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand.StreamInputSource</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/GsaCommunicationHandler.html#start()"><B>start()</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/GsaCommunicationHandler.html#stop(int)"><B>stop(int)</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.StreamInputSource.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>StreamingCommand.StreamInputSource</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</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.StreamInputSource.html#StreamingCommand.StreamInputSource(java.io.InputStream)"><B>StreamingCommand.StreamInputSource(InputStream)</B></A> - 
Constructor for class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.StreamInputSource.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand.StreamInputSource</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.StreamOutputSink.html" title="class in com.google.enterprise.adaptor.prebuilt"><B>StreamingCommand.StreamOutputSink</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/prebuilt/package-summary.html">com.google.enterprise.adaptor.prebuilt</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.<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.StreamOutputSink.html#StreamingCommand.StreamOutputSink(java.io.OutputStream)"><B>StreamingCommand.StreamOutputSink(OutputStream)</B></A> - 
Constructor for class com.google.enterprise.adaptor.prebuilt.<A HREF="./com/google/enterprise/adaptor/prebuilt/StreamingCommand.StreamOutputSink.html" title="class in com.google.enterprise.adaptor.prebuilt">StreamingCommand.StreamOutputSink</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_T_"><!-- --></A><H2>
<B>T</B></H2>
<DL>
<DT><A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.html" title="class in com.google.enterprise.adaptor.examples"><B>TableGeneratorTransform</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/examples/package-summary.html">com.google.enterprise.adaptor.examples</A><DD>This transform takes in a CSV file, generates an HTML table with the data,
 and inserts it into a template HTML file that's provided by the user.<DT><A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.html#TableGeneratorTransform()"><B>TableGeneratorTransform()</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.html" title="class in com.google.enterprise.adaptor.examples">TableGeneratorTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.html#TableGeneratorTransform(java.lang.String)"><B>TableGeneratorTransform(String)</B></A> - 
Constructor for class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.html" title="class in com.google.enterprise.adaptor.examples">TableGeneratorTransform</A>
<DD>&nbsp;
<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/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/DocumentTransform.html#transform(java.io.ByteArrayOutputStream, java.io.OutputStream, com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(ByteArrayOutputStream, OutputStream, 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>Read data from <code>contentIn</code>, transform it, and write it to <code>contentOut</code>.
<DT><A HREF="./com/google/enterprise/adaptor/examples/CalaisNERTransform.html#transform(java.io.ByteArrayOutputStream, java.io.OutputStream, com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(ByteArrayOutputStream, OutputStream, Metadata, Map&lt;String, String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/CalaisNERTransform.html" title="class in com.google.enterprise.adaptor.examples">CalaisNERTransform</A>
<DD>This transform must take in a parameter of the form:
 <code>(OpenCalaisAPIKey, key)</code>

 Optionally, extra parameters can be passed in to set which entity types to detect.
<DT><A HREF="./com/google/enterprise/adaptor/examples/MetaTaggerTransform.html#transform(java.io.ByteArrayOutputStream, java.io.OutputStream, com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(ByteArrayOutputStream, OutputStream, Metadata, Map&lt;String, String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/MetaTaggerTransform.html" title="class in com.google.enterprise.adaptor.examples">MetaTaggerTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.html#transform(java.io.ByteArrayOutputStream, java.io.OutputStream, com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(ByteArrayOutputStream, OutputStream, Metadata, Map&lt;String, String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.examples.<A HREF="./com/google/enterprise/adaptor/examples/TableGeneratorTransform.html" title="class in com.google.enterprise.adaptor.examples">TableGeneratorTransform</A>
<DD>&nbsp;
<DT><A HREF="./com/google/enterprise/adaptor/prebuilt/CommandLineTransform.html#transform(java.io.ByteArrayOutputStream, java.io.OutputStream, com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(ByteArrayOutputStream, OutputStream, 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;
<DT><A HREF="./com/google/enterprise/adaptor/TransformPipeline.html#transform(byte[], java.io.OutputStream, com.google.enterprise.adaptor.Metadata, java.util.Map)"><B>transform(byte[], OutputStream, Metadata, Map&lt;String, String&gt;)</B></A> - 
Method in class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/TransformPipeline.html" title="class in com.google.enterprise.adaptor">TransformPipeline</A>
<DD>Transform <code>contentIn</code> and <code>metadata</code>.
<DT><A HREF="./com/google/enterprise/adaptor/TransformException.html" title="class in com.google.enterprise.adaptor"><B>TransformException</B></A> - Exception in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Exception produced by <A HREF="./com/google/enterprise/adaptor/DocumentTransform.html" title="interface in com.google.enterprise.adaptor"><CODE>DocumentTransform</CODE></A>s and <A HREF="./com/google/enterprise/adaptor/DocumentTransform.html" title="interface in com.google.enterprise.adaptor"><CODE>DocumentTransform</CODE></A> in the case of a fatal error.<DT><A HREF="./com/google/enterprise/adaptor/TransformException.html#TransformException(java.lang.String)"><B>TransformException(String)</B></A> - 
Constructor for exception com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/TransformException.html" title="class in com.google.enterprise.adaptor">TransformException</A>
<DD>Constructs a new exception with a detailed message.
<DT><A HREF="./com/google/enterprise/adaptor/TransformException.html#TransformException(java.lang.String, java.lang.Throwable)"><B>TransformException(String, Throwable)</B></A> - 
Constructor for exception com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/TransformException.html" title="class in com.google.enterprise.adaptor">TransformException</A>
<DD>Constructs a new exception with a detailed message and a cause initialized
 to <code>cause</code>.
<DT><A HREF="./com/google/enterprise/adaptor/TransformException.html#TransformException(java.lang.Throwable)"><B>TransformException(Throwable)</B></A> - 
Constructor for exception com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/TransformException.html" title="class in com.google.enterprise.adaptor">TransformException</A>
<DD>Constructs a new exception with a <code>null</code> message and a cause
 initalized to <code>cause</code>.
<DT><A HREF="./com/google/enterprise/adaptor/TransformPipeline.html" title="class in com.google.enterprise.adaptor"><B>TransformPipeline</B></A> - Class in <A HREF="./com/google/enterprise/adaptor/package-summary.html">com.google.enterprise.adaptor</A><DD>Modify content and metadata using multiple serial transforms.<DT><A HREF="./com/google/enterprise/adaptor/TransformPipeline.html#TransformPipeline(java.util.List)"><B>TransformPipeline(List&lt;? extends DocumentTransform&gt;)</B></A> - 
Constructor for class com.google.enterprise.adaptor.<A HREF="./com/google/enterprise/adaptor/TransformPipeline.html" title="class in com.google.enterprise.adaptor">TransformPipeline</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/Config.html#useAdaptorAutoUnzip()"><B>useAdaptorAutoUnzip()</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>Automatically unzips and <code>DocId</code>s ending in <code>.zip</code> and provides
 them to the GSA.
</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>
