<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.3"/>
<title>Lucene.Net: Lucene.Net.Index.StringFieldEnumerator Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/search.js"></script>
<script type="text/javascript">
  $(document).ready(function() { searchBox.OnSelectItem(0); });
</script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td id="projectlogo"><img alt="Logo" src="lucene-net-icon-128x128.png"/></td>
  <td style="padding-left: 0.5em;">
   <div id="projectname">Lucene.Net
   &#160;<span id="projectnumber">3.0.3</span>
   </div>
   <div id="projectbrief">Lucene.Net is a .NET port of the Java Lucene Indexing Library</div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.8.3 -->
<script type="text/javascript">
var searchBox = new SearchBox("searchBox", "search",false,'Search');
</script>
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="Index.html"><span>Main&#160;Page</span></a></li>
      <li><a href="namespaces.html"><span>Packages</span></a></li>
      <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
      <li><a href="files.html"><span>Files</span></a></li>
      <li>
        <div id="MSearchBox" class="MSearchBoxInactive">
        <span class="left">
          <img id="MSearchSelect" src="search/mag_sel.png"
               onmouseover="return searchBox.OnSearchSelectShow()"
               onmouseout="return searchBox.OnSearchSelectHide()"
               alt=""/>
          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)" 
               onblur="searchBox.OnSearchFieldFocus(false)" 
               onkeyup="searchBox.OnSearchFieldChange(event)"/>
          </span><span class="right">
            <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
          </span>
        </div>
      </li>
    </ul>
  </div>
  <div id="navrow2" class="tabs2">
    <ul class="tablist">
      <li><a href="annotated.html"><span>Class&#160;List</span></a></li>
      <li><a href="classes.html"><span>Class&#160;Index</span></a></li>
      <li><a href="hierarchy.html"><span>Class&#160;Hierarchy</span></a></li>
      <li><a href="functions.html"><span>Class&#160;Members</span></a></li>
    </ul>
  </div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark">&#160;</span>All</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark">&#160;</span>Classes</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark">&#160;</span>Namespaces</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark">&#160;</span>Files</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(4)"><span class="SelectionMark">&#160;</span>Functions</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(5)"><span class="SelectionMark">&#160;</span>Variables</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(6)"><span class="SelectionMark">&#160;</span>Typedefs</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(7)"><span class="SelectionMark">&#160;</span>Enumerations</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(8)"><span class="SelectionMark">&#160;</span>Properties</a></div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespace_lucene.html">Lucene</a></li><li class="navelem"><a class="el" href="namespace_lucene_1_1_net.html">Net</a></li><li class="navelem"><a class="el" href="namespace_lucene_1_1_net_1_1_index.html">Index</a></li><li class="navelem"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_string_field_enumerator.html">StringFieldEnumerator</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#pro-methods">Protected Member Functions</a> &#124;
<a href="class_lucene_1_1_net_1_1_index_1_1_string_field_enumerator-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Lucene.Net.Index.StringFieldEnumerator Class Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p>Implementation for enumerating over terms with a string value.  
 <a href="class_lucene_1_1_net_1_1_index_1_1_string_field_enumerator.html#details">More...</a></p>

<p>Inherits <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html">Lucene.Net.Index.FieldEnumerator&lt; T &gt;</a>.</p>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
Public Member Functions</h2></td></tr>
<tr class="memitem:aef9b7ae44e499986a86ef396baa88893"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_string_field_enumerator.html#aef9b7ae44e499986a86ef396baa88893">StringFieldEnumerator</a> (<a class="el" href="class_lucene_1_1_net_1_1_index_1_1_index_reader.html">IndexReader</a> reader, string fieldName)</td></tr>
<tr class="memdesc:aef9b7ae44e499986a86ef396baa88893"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct an enumerator over one field.  <a href="#aef9b7ae44e499986a86ef396baa88893"></a><br/></td></tr>
<tr class="separator:aef9b7ae44e499986a86ef396baa88893"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a887f30abe677649c4260d9066bdf9eba"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_string_field_enumerator.html#a887f30abe677649c4260d9066bdf9eba">StringFieldEnumerator</a> (<a class="el" href="class_lucene_1_1_net_1_1_index_1_1_index_reader.html">IndexReader</a> reader, string fieldName, bool <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#ae6765a92d1ed66f04689cdb54d3c1f1f">includeDocs</a>)</td></tr>
<tr class="memdesc:a887f30abe677649c4260d9066bdf9eba"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct an enumerator over one field.  <a href="#a887f30abe677649c4260d9066bdf9eba"></a><br/></td></tr>
<tr class="separator:a887f30abe677649c4260d9066bdf9eba"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html">Lucene.Net.Index.FieldEnumerator&lt; T &gt;</a></td></tr>
<tr class="memitem:ad7d9f1aea450472c854d07df887a21fa inherit pub_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#ad7d9f1aea450472c854d07df887a21fa">Dispose</a> ()</td></tr>
<tr class="memdesc:ad7d9f1aea450472c854d07df887a21fa inherit pub_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Dispose of the instance.  <a href="#ad7d9f1aea450472c854d07df887a21fa"></a><br/></td></tr>
<tr class="separator:ad7d9f1aea450472c854d07df887a21fa inherit pub_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-methods"></a>
Protected Member Functions</h2></td></tr>
<tr class="memitem:a6d92a797d81854cc5dfaa648dad39ec3"><td class="memItemLeft" align="right" valign="top">override bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_string_field_enumerator.html#a6d92a797d81854cc5dfaa648dad39ec3">TryParse</a> (string s)</td></tr>
<tr class="memdesc:a6d92a797d81854cc5dfaa648dad39ec3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets the value of current.  <a href="#a6d92a797d81854cc5dfaa648dad39ec3"></a><br/></td></tr>
<tr class="separator:a6d92a797d81854cc5dfaa648dad39ec3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4')"><img src="closed.png" alt="-"/>&#160;Protected Member Functions inherited from <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html">Lucene.Net.Index.FieldEnumerator&lt; T &gt;</a></td></tr>
<tr class="memitem:aee5dad1f15cb3fdc750137074b632e7a inherit pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#aee5dad1f15cb3fdc750137074b632e7a">Init</a> (<a class="el" href="class_lucene_1_1_net_1_1_index_1_1_index_reader.html">IndexReader</a> reader, string field)</td></tr>
<tr class="memdesc:aee5dad1f15cb3fdc750137074b632e7a inherit pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initialization method called by subclasses to simulate a shared base constructor as generic classes cannot have a parameterized ctor.  <a href="#aee5dad1f15cb3fdc750137074b632e7a"></a><br/></td></tr>
<tr class="separator:aee5dad1f15cb3fdc750137074b632e7a inherit pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac421cba1ebcd6dbe477f059e574f8307 inherit pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#ac421cba1ebcd6dbe477f059e574f8307">Init</a> (<a class="el" href="class_lucene_1_1_net_1_1_index_1_1_index_reader.html">IndexReader</a> reader, string fieldName, bool <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#ae6765a92d1ed66f04689cdb54d3c1f1f">includeDocs</a>)</td></tr>
<tr class="memdesc:ac421cba1ebcd6dbe477f059e574f8307 inherit pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initialization method called by subclasses to simulate a shared base constructor as generic classes cannot have a parameterized ctor.  <a href="#ac421cba1ebcd6dbe477f059e574f8307"></a><br/></td></tr>
<tr class="separator:ac421cba1ebcd6dbe477f059e574f8307 inherit pro_methods_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
Additional Inherited Members</h2></td></tr>
<tr class="inherit_header pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4')"><img src="closed.png" alt="-"/>&#160;Protected Attributes inherited from <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html">Lucene.Net.Index.FieldEnumerator&lt; T &gt;</a></td></tr>
<tr class="memitem:ae6765a92d1ed66f04689cdb54d3c1f1f inherit pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#ae6765a92d1ed66f04689cdb54d3c1f1f">includeDocs</a></td></tr>
<tr class="memdesc:ae6765a92d1ed66f04689cdb54d3c1f1f inherit pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Whether the enumerator will include <a class="el" href="interface_lucene_1_1_net_1_1_index_1_1_term_docs.html" title="TermDocs provides an interface for enumerating &lt;document, frequency&gt; pairs for a term. The document portion names each document containing the term. Documents are indicated by number. The frequency portion gives the number of times the term occurred in each document. The pairs are ordered by document number. ">TermDocs</a>.  <a href="#ae6765a92d1ed66f04689cdb54d3c1f1f"></a><br/></td></tr>
<tr class="separator:ae6765a92d1ed66f04689cdb54d3c1f1f inherit pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a02c905fb5e3c851c969bf8390a1cd713 inherit pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memItemLeft" align="right" valign="top">TermEnumerator&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#a02c905fb5e3c851c969bf8390a1cd713">tEnum</a></td></tr>
<tr class="memdesc:a02c905fb5e3c851c969bf8390a1cd713 inherit pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="mdescLeft">&#160;</td><td class="mdescRight">The specialized <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_term_enum.html" title="Abstract class for enumerating terms. Term enumerations are always ordered by Term.compareTo(). Each term in the enumeration is greater than all that precede it. ">TermEnum</a> enumerator.  <a href="#a02c905fb5e3c851c969bf8390a1cd713"></a><br/></td></tr>
<tr class="separator:a02c905fb5e3c851c969bf8390a1cd713 inherit pro_attribs_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td colspan="2" onclick="javascript:toggleInherit('properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html">Lucene.Net.Index.FieldEnumerator&lt; T &gt;</a></td></tr>
<tr class="memitem:ac6b4e3b40e3d2b3e2c82dd9290db2b25 inherit properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memItemLeft" align="right" valign="top">TermEnumerator&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#ac6b4e3b40e3d2b3e2c82dd9290db2b25">Terms</a><code> [get]</code></td></tr>
<tr class="memdesc:ac6b4e3b40e3d2b3e2c82dd9290db2b25 inherit properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the enumerator for the terms.  <a href="#ac6b4e3b40e3d2b3e2c82dd9290db2b25"></a><br/></td></tr>
<tr class="separator:ac6b4e3b40e3d2b3e2c82dd9290db2b25 inherit properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9977258bdfdd90e6456fb2190bfde75d inherit properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_term_doc_enumerator_1_1_term_doc_using_terms_enumerator.html">TermDocEnumerator.TermDocUsingTermsEnumerator</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#a9977258bdfdd90e6456fb2190bfde75d">Docs</a><code> [get]</code></td></tr>
<tr class="memdesc:a9977258bdfdd90e6456fb2190bfde75d inherit properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the enumerator for the <a class="el" href="interface_lucene_1_1_net_1_1_index_1_1_term_docs.html" title="TermDocs provides an interface for enumerating &lt;document, frequency&gt; pairs for a term. The document portion names each document containing the term. Documents are indicated by number. The frequency portion gives the number of times the term occurred in each document. The pairs are ordered by document number. ">TermDocs</a>.  <a href="#a9977258bdfdd90e6456fb2190bfde75d"></a><br/></td></tr>
<tr class="separator:a9977258bdfdd90e6456fb2190bfde75d inherit properties_class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p>Implementation for enumerating over terms with a string value. </p>

<p>Definition at line <a class="el" href="_field_enumerator_8cs_source.html#l00519">519</a> of file <a class="el" href="_field_enumerator_8cs_source.html">FieldEnumerator.cs</a>.</p>
</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<a class="anchor" id="aef9b7ae44e499986a86ef396baa88893"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Lucene.Net.Index.StringFieldEnumerator.StringFieldEnumerator </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_index_reader.html">IndexReader</a>&#160;</td>
          <td class="paramname"><em>reader</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">string&#160;</td>
          <td class="paramname"><em>fieldName</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Construct an enumerator over one field. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">reader</td><td><a class="el" href="namespace_lucene_1_1_net_1_1_index.html">Index</a> reader.</td></tr>
    <tr><td class="paramname">fieldName</td><td>The field to read.</td></tr>
  </table>
  </dd>
</dl>

<p>Definition at line <a class="el" href="_field_enumerator_8cs_source.html#l00526">526</a> of file <a class="el" href="_field_enumerator_8cs_source.html">FieldEnumerator.cs</a>.</p>

</div>
</div>
<a class="anchor" id="a887f30abe677649c4260d9066bdf9eba"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Lucene.Net.Index.StringFieldEnumerator.StringFieldEnumerator </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="class_lucene_1_1_net_1_1_index_1_1_index_reader.html">IndexReader</a>&#160;</td>
          <td class="paramname"><em>reader</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">string&#160;</td>
          <td class="paramname"><em>fieldName</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>includeDocs</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Construct an enumerator over one field. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">reader</td><td><a class="el" href="namespace_lucene_1_1_net_1_1_index.html">Index</a> reader.</td></tr>
    <tr><td class="paramname">fieldName</td><td>The field to read.</td></tr>
    <tr><td class="paramname">includeDocs</td><td>Whether the <a class="el" href="interface_lucene_1_1_net_1_1_index_1_1_term_docs.html" title="TermDocs provides an interface for enumerating &lt;document, frequency&gt; pairs for a term. The document portion names each document containing the term. Documents are indicated by number. The frequency portion gives the number of times the term occurred in each document. The pairs are ordered by document number. ">TermDocs</a> will also be enumerated.</td></tr>
  </table>
  </dd>
</dl>

<p>Definition at line <a class="el" href="_field_enumerator_8cs_source.html#l00537">537</a> of file <a class="el" href="_field_enumerator_8cs_source.html">FieldEnumerator.cs</a>.</p>

</div>
</div>
<h2 class="groupheader">Member Function Documentation</h2>
<a class="anchor" id="a6d92a797d81854cc5dfaa648dad39ec3"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override bool Lucene.Net.Index.StringFieldEnumerator.TryParse </td>
          <td>(</td>
          <td class="paramtype">string&#160;</td>
          <td class="paramname"><em>s</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">protected</span><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sets the value of current. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">s</td><td>The string.</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Always true.</dd></dl>

<p>Implements <a class="el" href="class_lucene_1_1_net_1_1_index_1_1_field_enumerator_3_01_t_01_4.html#aa0ad76752f697b90b5ad41119545fd18">Lucene.Net.Index.FieldEnumerator&lt; T &gt;</a>.</p>

<p>Definition at line <a class="el" href="_field_enumerator_8cs_source.html#l00547">547</a> of file <a class="el" href="_field_enumerator_8cs_source.html">FieldEnumerator.cs</a>.</p>

</div>
</div>
<hr/>The documentation for this class was generated from the following file:<ul>
<li>contrib/Core/Index/<a class="el" href="_field_enumerator_8cs_source.html">FieldEnumerator.cs</a></li>
</ul>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated on Thu Jan 3 2013 02:12:49 for Lucene.Net by &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/>
</a> 1.8.3
</small></address>
</body>
</html>
