<!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.Analysis.LowerCaseTokenizer 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_analysis.html">Analysis</a></li><li class="navelem"><a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html">LowerCaseTokenizer</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Lucene.Net.Analysis.LowerCaseTokenizer Class Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p><a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a> performs the function of <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html" title="A LetterTokenizer is a tokenizer that divides text at non-letters. That&#39;s to say, it defines tokens a...">LetterTokenizer</a> and <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_filter.html" title="Normalizes token text to lower case.">LowerCaseFilter</a> together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html" title="A LetterTokenizer is a tokenizer that divides text at non-letters. That&#39;s to say, it defines tokens a...">LetterTokenizer</a> and <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_filter.html" title="Normalizes token text to lower case.">LowerCaseFilter</a>, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces.  
 <a href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html#details">More...</a></p>

<p>Inherits <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html">Lucene.Net.Analysis.LetterTokenizer</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:addefde5348078ad10a3de048d73c8351"><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_analysis_1_1_lower_case_tokenizer.html#addefde5348078ad10a3de048d73c8351">LowerCaseTokenizer</a> (System.IO.TextReader @in)</td></tr>
<tr class="memdesc:addefde5348078ad10a3de048d73c8351"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a>.  <a href="#addefde5348078ad10a3de048d73c8351"></a><br/></td></tr>
<tr class="separator:addefde5348078ad10a3de048d73c8351"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae8202122be2d80657fd696fc7e341875"><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_analysis_1_1_lower_case_tokenizer.html#ae8202122be2d80657fd696fc7e341875">LowerCaseTokenizer</a> (<a class="el" href="_char_tokenizer_8cs.html#aed60c4e663aea1a7dec59cf4c3710058">AttributeSource</a> source, System.IO.TextReader @in)</td></tr>
<tr class="memdesc:ae8202122be2d80657fd696fc7e341875"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a> using a given <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source.html#af8654555ddde74d7e463266371f3508c" title="An AttributeSource using the default attribute factory AttributeSource.AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY.">AttributeSource</a>.  <a href="#ae8202122be2d80657fd696fc7e341875"></a><br/></td></tr>
<tr class="separator:ae8202122be2d80657fd696fc7e341875"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aff6b26ab82bcc96ee1de12209b1490c7"><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_analysis_1_1_lower_case_tokenizer.html#aff6b26ab82bcc96ee1de12209b1490c7">LowerCaseTokenizer</a> (<a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html">AttributeFactory</a> factory, System.IO.TextReader @in)</td></tr>
<tr class="memdesc:aff6b26ab82bcc96ee1de12209b1490c7"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a> using a given <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html" title="An AttributeFactory creates instances of Attributes.">Lucene.Net.Util.AttributeSource.AttributeFactory</a>.  <a href="#aff6b26ab82bcc96ee1de12209b1490c7"></a><br/></td></tr>
<tr class="separator:aff6b26ab82bcc96ee1de12209b1490c7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html">Lucene.Net.Analysis.LetterTokenizer</a></td></tr>
<tr class="memitem:a6dc00a269c6bbe2c40ce757b74b40e0e inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><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_analysis_1_1_letter_tokenizer.html#a6dc00a269c6bbe2c40ce757b74b40e0e">LetterTokenizer</a> (System.IO.TextReader @in)</td></tr>
<tr class="memdesc:a6dc00a269c6bbe2c40ce757b74b40e0e inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html" title="A LetterTokenizer is a tokenizer that divides text at non-letters. That&#39;s to say, it defines tokens a...">LetterTokenizer</a>.  <a href="#a6dc00a269c6bbe2c40ce757b74b40e0e"></a><br/></td></tr>
<tr class="separator:a6dc00a269c6bbe2c40ce757b74b40e0e inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae5a07cff497bd508739a2d15de461627 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><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_analysis_1_1_letter_tokenizer.html#ae5a07cff497bd508739a2d15de461627">LetterTokenizer</a> (<a class="el" href="_char_tokenizer_8cs.html#aed60c4e663aea1a7dec59cf4c3710058">AttributeSource</a> source, System.IO.TextReader @in)</td></tr>
<tr class="memdesc:ae5a07cff497bd508739a2d15de461627 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html" title="A LetterTokenizer is a tokenizer that divides text at non-letters. That&#39;s to say, it defines tokens a...">LetterTokenizer</a> using a given <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source.html#af8654555ddde74d7e463266371f3508c" title="An AttributeSource using the default attribute factory AttributeSource.AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY.">AttributeSource</a>.  <a href="#ae5a07cff497bd508739a2d15de461627"></a><br/></td></tr>
<tr class="separator:ae5a07cff497bd508739a2d15de461627 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6cb4818a38b35e03118071fec95e577a inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><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_analysis_1_1_letter_tokenizer.html#a6cb4818a38b35e03118071fec95e577a">LetterTokenizer</a> (<a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html">AttributeFactory</a> factory, System.IO.TextReader @in)</td></tr>
<tr class="memdesc:a6cb4818a38b35e03118071fec95e577a inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><td class="mdescLeft">&#160;</td><td class="mdescRight">Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html" title="A LetterTokenizer is a tokenizer that divides text at non-letters. That&#39;s to say, it defines tokens a...">LetterTokenizer</a> using a given <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html" title="An AttributeFactory creates instances of Attributes.">Lucene.Net.Util.AttributeSource.AttributeFactory</a>.  <a href="#a6cb4818a38b35e03118071fec95e577a"></a><br/></td></tr>
<tr class="separator:a6cb4818a38b35e03118071fec95e577a inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer.html">Lucene.Net.Analysis.CharTokenizer</a></td></tr>
<tr class="memitem:a24d19295780e10c1ea34f895a9d2d0a3 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><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_analysis_1_1_char_tokenizer.html#a24d19295780e10c1ea34f895a9d2d0a3">IncrementToken</a> ()</td></tr>
<tr class="memdesc:a24d19295780e10c1ea34f895a9d2d0a3 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="mdescLeft">&#160;</td><td class="mdescRight">Consumers (i.e., <a class="el" href="_f_s_directory_8cs.html#a7d90824eac5b2433e714cc9faeb34d1b">IndexWriter</a>) use this method to advance the stream to the next token. Implementing classes must implement this method and update the appropriate <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute.html" title="Base class for Attributes that can be added to a Lucene.Net.Util.AttributeSource. Attributes are used...">Util.Attribute</a>s with the attributes of the next token.  <a href="#a24d19295780e10c1ea34f895a9d2d0a3"></a><br/></td></tr>
<tr class="separator:a24d19295780e10c1ea34f895a9d2d0a3 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2e7b8a28d1894a6ac3770492417f1d74 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="memItemLeft" align="right" valign="top">override void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer.html#a2e7b8a28d1894a6ac3770492417f1d74">End</a> ()</td></tr>
<tr class="memdesc:a2e7b8a28d1894a6ac3770492417f1d74 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="mdescLeft">&#160;</td><td class="mdescRight">This method is called by the consumer after the last token has been consumed, after <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer.html#a24d19295780e10c1ea34f895a9d2d0a3" title="Consumers (i.e., IndexWriter) use this method to advance the stream to the next token. Implementing classes must implement this method and update the appropriate Util.Attributes with the attributes of the next token.">IncrementToken</a> returned <code>false</code> (using the new <code><a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_token_stream.html" title="A TokenStream enumerates the sequence of tokens, either from Fields of a Document or from query text...">TokenStream</a></code> API). Streams implementing the old API should upgrade to use this feature. This method can be used to perform any end-of-stream operations, such as setting the final offset of a stream. The final offset of a stream might differ from the offset of the last token eg in case one or more whitespaces followed after the last token, but a <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_whitespace_tokenizer.html" title="A WhitespaceTokenizer is a tokenizer that divides text at whitespace. Adjacent sequences of non-White...">WhitespaceTokenizer</a> was used.  <a href="#a2e7b8a28d1894a6ac3770492417f1d74"></a><br/></td></tr>
<tr class="separator:a2e7b8a28d1894a6ac3770492417f1d74 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af0b0251de184d2bbeea75e2f39c30433 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="memItemLeft" align="right" valign="top">override void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer.html#af0b0251de184d2bbeea75e2f39c30433">Reset</a> (System.IO.TextReader input)</td></tr>
<tr class="memdesc:af0b0251de184d2bbeea75e2f39c30433 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="mdescLeft">&#160;</td><td class="mdescRight">Expert: Reset the tokenizer to a new reader. Typically, an analyzer (in its reusableTokenStream method) will use this to re-use a previously created tokenizer.  <a href="#af0b0251de184d2bbeea75e2f39c30433"></a><br/></td></tr>
<tr class="separator:af0b0251de184d2bbeea75e2f39c30433 inherit pub_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><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_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer')"><img src="closed.png" alt="-"/>&#160;Protected Member Functions inherited from <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer.html">Lucene.Net.Analysis.CharTokenizer</a></td></tr>
<tr class="memitem:a3a7cb1beb6cfd78756dedf85377cd03c inherit pro_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><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_analysis_1_1_char_tokenizer.html#a3a7cb1beb6cfd78756dedf85377cd03c">CharTokenizer</a> (System.IO.TextReader input)</td></tr>
<tr class="separator:a3a7cb1beb6cfd78756dedf85377cd03c inherit pro_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a04456d323cc22a3ed397c292edb4a5e0 inherit pro_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><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_analysis_1_1_char_tokenizer.html#a04456d323cc22a3ed397c292edb4a5e0">CharTokenizer</a> (<a class="el" href="_char_tokenizer_8cs.html#aed60c4e663aea1a7dec59cf4c3710058">AttributeSource</a> source, System.IO.TextReader input)</td></tr>
<tr class="separator:a04456d323cc22a3ed397c292edb4a5e0 inherit pro_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6f54dabfce0a7103155e7ce3e48c6e36 inherit pro_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><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_analysis_1_1_char_tokenizer.html#a6f54dabfce0a7103155e7ce3e48c6e36">CharTokenizer</a> (<a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html">AttributeFactory</a> factory, System.IO.TextReader input)</td></tr>
<tr class="separator:a6f54dabfce0a7103155e7ce3e48c6e36 inherit pro_methods_class_lucene_1_1_net_1_1_analysis_1_1_char_tokenizer"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source"><td colspan="2" onclick="javascript:toggleInherit('properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source.html">Lucene.Net.Util.AttributeSource</a></td></tr>
<tr class="memitem:a2d4a930c02c088e18b14c25e94f5089b inherit properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source"><td class="memItemLeft" align="right" valign="top">virtual <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html">AttributeFactory</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source.html#a2d4a930c02c088e18b14c25e94f5089b">Factory</a><code> [get]</code></td></tr>
<tr class="memdesc:a2d4a930c02c088e18b14c25e94f5089b inherit properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the used <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html" title="An AttributeFactory creates instances of Attributes.">AttributeFactory</a>. <a href="#a2d4a930c02c088e18b14c25e94f5089b"></a><br/></td></tr>
<tr class="separator:a2d4a930c02c088e18b14c25e94f5089b inherit properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7335286469fdd008e4a7d40cc97056ab inherit properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source"><td class="memItemLeft" align="right" valign="top">virtual bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source.html#a7335286469fdd008e4a7d40cc97056ab">HasAttributes</a><code> [get]</code></td></tr>
<tr class="memdesc:a7335286469fdd008e4a7d40cc97056ab inherit properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true, iff this <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source.html" title="An AttributeSource contains a list of different Attributes, and methods to add and get them...">AttributeSource</a> has any attributes  <a href="#a7335286469fdd008e4a7d40cc97056ab"></a><br/></td></tr>
<tr class="separator:a7335286469fdd008e4a7d40cc97056ab inherit properties_class_lucene_1_1_net_1_1_util_1_1_attribute_source"><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><a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a> performs the function of <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html" title="A LetterTokenizer is a tokenizer that divides text at non-letters. That&#39;s to say, it defines tokens a...">LetterTokenizer</a> and <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_filter.html" title="Normalizes token text to lower case.">LowerCaseFilter</a> together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_letter_tokenizer.html" title="A LetterTokenizer is a tokenizer that divides text at non-letters. That&#39;s to say, it defines tokens a...">LetterTokenizer</a> and <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_filter.html" title="Normalizes token text to lower case.">LowerCaseFilter</a>, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. </p>
<p>Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. </p>

<p>Definition at line <a class="el" href="_lower_case_tokenizer_8cs_source.html#l00032">32</a> of file <a class="el" href="_lower_case_tokenizer_8cs_source.html">LowerCaseTokenizer.cs</a>.</p>
</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<a class="anchor" id="addefde5348078ad10a3de048d73c8351"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Lucene.Net.Analysis.LowerCaseTokenizer.LowerCaseTokenizer </td>
          <td>(</td>
          <td class="paramtype">System.IO.TextReader @&#160;</td>
          <td class="paramname"><em>in</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a>. </p>

<p>Definition at line <a class="el" href="_lower_case_tokenizer_8cs_source.html#l00035">35</a> of file <a class="el" href="_lower_case_tokenizer_8cs_source.html">LowerCaseTokenizer.cs</a>.</p>

</div>
</div>
<a class="anchor" id="ae8202122be2d80657fd696fc7e341875"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Lucene.Net.Analysis.LowerCaseTokenizer.LowerCaseTokenizer </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="_char_tokenizer_8cs.html#aed60c4e663aea1a7dec59cf4c3710058">AttributeSource</a>&#160;</td>
          <td class="paramname"><em>source</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">System.IO.TextReader @&#160;</td>
          <td class="paramname"><em>in</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a> using a given <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source.html#af8654555ddde74d7e463266371f3508c" title="An AttributeSource using the default attribute factory AttributeSource.AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY.">AttributeSource</a>. </p>

<p>Definition at line <a class="el" href="_lower_case_tokenizer_8cs_source.html#l00041">41</a> of file <a class="el" href="_lower_case_tokenizer_8cs_source.html">LowerCaseTokenizer.cs</a>.</p>

</div>
</div>
<a class="anchor" id="aff6b26ab82bcc96ee1de12209b1490c7"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Lucene.Net.Analysis.LowerCaseTokenizer.LowerCaseTokenizer </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html">AttributeFactory</a>&#160;</td>
          <td class="paramname"><em>factory</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">System.IO.TextReader @&#160;</td>
          <td class="paramname"><em>in</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Construct a new <a class="el" href="class_lucene_1_1_net_1_1_analysis_1_1_lower_case_tokenizer.html" title="LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation. Note: this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces. ">LowerCaseTokenizer</a> using a given <a class="el" href="class_lucene_1_1_net_1_1_util_1_1_attribute_source_1_1_attribute_factory.html" title="An AttributeFactory creates instances of Attributes.">Lucene.Net.Util.AttributeSource.AttributeFactory</a>. </p>

<p>Definition at line <a class="el" href="_lower_case_tokenizer_8cs_source.html#l00047">47</a> of file <a class="el" href="_lower_case_tokenizer_8cs_source.html">LowerCaseTokenizer.cs</a>.</p>

</div>
</div>
<hr/>The documentation for this class was generated from the following file:<ul>
<li>core/Analysis/<a class="el" href="_lower_case_tokenizer_8cs_source.html">LowerCaseTokenizer.cs</a></li>
</ul>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated on Thu Jan 3 2013 02:12:48 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>
