<!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.Store.BufferedIndexInput 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_store.html">Store</a></li><li class="navelem"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html">BufferedIndexInput</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#pub-attribs">Public Attributes</a> &#124;
<a href="#pro-methods">Protected Member Functions</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Lucene.Net.Store.BufferedIndexInput Class Reference<span class="mlabels"><span class="mlabel">abstract</span></span></div>  </div>
</div><!--header-->
<div class="contents">

<p>Base implementation class for buffered <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html" title="Abstract base class for input from a file in a Directory. A random-access input stream. Used for all Lucene index input operations. ">IndexInput</a>.  
 <a href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#details">More...</a></p>

<p>Inherits <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html">Lucene.Net.Store.IndexInput</a>, and ICloneable.</p>

<p>Inherited by Lucene.Net.Store.SimpleFSDirectory.SimpleFSIndexInput.</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:a9b246c7d1caa549dfe3c845b422d7493"><td class="memItemLeft" align="right" valign="top">override byte&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a9b246c7d1caa549dfe3c845b422d7493">ReadByte</a> ()</td></tr>
<tr class="memdesc:a9b246c7d1caa549dfe3c845b422d7493"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads and returns a single byte. <a href="#a9b246c7d1caa549dfe3c845b422d7493"></a><br/></td></tr>
<tr class="separator:a9b246c7d1caa549dfe3c845b422d7493"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afb59e7f3d587cf2aeefe41da40ea7278"><td class="memItemLeft" align="right" valign="top">virtual void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#afb59e7f3d587cf2aeefe41da40ea7278">SetBufferSize</a> (int newSize)</td></tr>
<tr class="memdesc:afb59e7f3d587cf2aeefe41da40ea7278"><td class="mdescLeft">&#160;</td><td class="mdescRight">Change the buffer size used by this <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html" title="Abstract base class for input from a file in a Directory. A random-access input stream. Used for all Lucene index input operations. ">IndexInput</a>  <a href="#afb59e7f3d587cf2aeefe41da40ea7278"></a><br/></td></tr>
<tr class="separator:afb59e7f3d587cf2aeefe41da40ea7278"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab72a40d6c16cd5c3d4e5919ac1279ffe"><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_store_1_1_buffered_index_input.html#ab72a40d6c16cd5c3d4e5919ac1279ffe">ReadBytes</a> (byte[] b, int offset, int len)</td></tr>
<tr class="memdesc:ab72a40d6c16cd5c3d4e5919ac1279ffe"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a specified number of bytes into an array at the specified offset. <a href="#ab72a40d6c16cd5c3d4e5919ac1279ffe"></a><br/></td></tr>
<tr class="separator:ab72a40d6c16cd5c3d4e5919ac1279ffe"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a46d25b8c06552053cd0aff8a123e6cfd"><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_store_1_1_buffered_index_input.html#a46d25b8c06552053cd0aff8a123e6cfd">ReadBytes</a> (byte[] b, int offset, int len, bool useBuffer)</td></tr>
<tr class="memdesc:a46d25b8c06552053cd0aff8a123e6cfd"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a specified number of bytes into an array at the specified offset with control over whether the read should be buffered (callers who have their own buffer should pass in "false" for useBuffer). Currently only <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html" title="Base implementation class for buffered IndexInput. ">BufferedIndexInput</a> respects this parameter.  <a href="#a46d25b8c06552053cd0aff8a123e6cfd"></a><br/></td></tr>
<tr class="separator:a46d25b8c06552053cd0aff8a123e6cfd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6178a13660e773df6b0091d4189a6f66"><td class="memItemLeft" align="right" valign="top">abstract void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a6178a13660e773df6b0091d4189a6f66">ReadInternal</a> (byte[] b, int offset, int length)</td></tr>
<tr class="memdesc:a6178a13660e773df6b0091d4189a6f66"><td class="mdescLeft">&#160;</td><td class="mdescRight">Expert: implements buffer refill. Reads bytes from the current position in the input.  <a href="#a6178a13660e773df6b0091d4189a6f66"></a><br/></td></tr>
<tr class="separator:a6178a13660e773df6b0091d4189a6f66"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7e9a8492f0572972e2b41bc4f1121166"><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_store_1_1_buffered_index_input.html#a7e9a8492f0572972e2b41bc4f1121166">Seek</a> (long pos)</td></tr>
<tr class="memdesc:a7e9a8492f0572972e2b41bc4f1121166"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets current position in this file, where the next read will occur. <a href="#a7e9a8492f0572972e2b41bc4f1121166"></a><br/></td></tr>
<tr class="separator:a7e9a8492f0572972e2b41bc4f1121166"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abd28d53004637abdea59552bdf870625"><td class="memItemLeft" align="right" valign="top">abstract void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#abd28d53004637abdea59552bdf870625">SeekInternal</a> (long pos)</td></tr>
<tr class="memdesc:abd28d53004637abdea59552bdf870625"><td class="mdescLeft">&#160;</td><td class="mdescRight">Expert: implements seek. Sets current position in this file, where the next <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a6178a13660e773df6b0091d4189a6f66" title="Expert: implements buffer refill. Reads bytes from the current position in the input. ">ReadInternal(byte[],int,int)</a> will occur.  <a href="#abd28d53004637abdea59552bdf870625"></a><br/></td></tr>
<tr class="separator:abd28d53004637abdea59552bdf870625"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2af4a6df705c09aeebdd8cc580dc4b30"><td class="memItemLeft" align="right" valign="top">override System.Object&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a2af4a6df705c09aeebdd8cc580dc4b30">Clone</a> ()</td></tr>
<tr class="memdesc:a2af4a6df705c09aeebdd8cc580dc4b30"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a clone of this stream.  <a href="#a2af4a6df705c09aeebdd8cc580dc4b30"></a><br/></td></tr>
<tr class="separator:a2af4a6df705c09aeebdd8cc580dc4b30"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html">Lucene.Net.Store.IndexInput</a></td></tr>
<tr class="memitem:a857b897c4072eec1c879fe55c0059d0b inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a857b897c4072eec1c879fe55c0059d0b">ReadInt</a> ()</td></tr>
<tr class="memdesc:a857b897c4072eec1c879fe55c0059d0b inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads four bytes and returns an int. <a href="#a857b897c4072eec1c879fe55c0059d0b"></a><br/></td></tr>
<tr class="separator:a857b897c4072eec1c879fe55c0059d0b inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7f1c43b12cec62a36619a2eef1d4a4b5 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a7f1c43b12cec62a36619a2eef1d4a4b5">ReadVInt</a> ()</td></tr>
<tr class="memdesc:a7f1c43b12cec62a36619a2eef1d4a4b5 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads an int stored in variable-length format. Reads between one and five bytes. Smaller values take fewer bytes. Negative numbers are not supported.  <a href="#a7f1c43b12cec62a36619a2eef1d4a4b5"></a><br/></td></tr>
<tr class="separator:a7f1c43b12cec62a36619a2eef1d4a4b5 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a99a4c612eedbf1b79598f8f620aa6e66 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a99a4c612eedbf1b79598f8f620aa6e66">ReadLong</a> ()</td></tr>
<tr class="memdesc:a99a4c612eedbf1b79598f8f620aa6e66 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads eight bytes and returns a long. <a href="#a99a4c612eedbf1b79598f8f620aa6e66"></a><br/></td></tr>
<tr class="separator:a99a4c612eedbf1b79598f8f620aa6e66 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a81424c259e715990e17ad7a368638b37 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a81424c259e715990e17ad7a368638b37">ReadVLong</a> ()</td></tr>
<tr class="memdesc:a81424c259e715990e17ad7a368638b37 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a long stored in variable-length format. Reads between one and nine bytes. Smaller values take fewer bytes. Negative numbers are not supported.  <a href="#a81424c259e715990e17ad7a368638b37"></a><br/></td></tr>
<tr class="separator:a81424c259e715990e17ad7a368638b37 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7c88afa405bc6da5a4ede918b57066b8 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a7c88afa405bc6da5a4ede918b57066b8">SetModifiedUTF8StringsMode</a> ()</td></tr>
<tr class="memdesc:a7c88afa405bc6da5a4ede918b57066b8 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Call this if readString should read characters stored in the old modified UTF8 format (length in java chars and java's modified UTF8 encoding). This is used for indices written pre-2.4 See LUCENE-510 for details.  <a href="#a7c88afa405bc6da5a4ede918b57066b8"></a><br/></td></tr>
<tr class="separator:a7c88afa405bc6da5a4ede918b57066b8 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4457179dbe62043d7ce63b8588fd4477 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual System.String&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a4457179dbe62043d7ce63b8588fd4477">ReadString</a> ()</td></tr>
<tr class="memdesc:a4457179dbe62043d7ce63b8588fd4477 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a string. <a href="#a4457179dbe62043d7ce63b8588fd4477"></a><br/></td></tr>
<tr class="separator:a4457179dbe62043d7ce63b8588fd4477 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a13b5828d33ea1400e49c1efd48a31de8 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a13b5828d33ea1400e49c1efd48a31de8">ReadChars</a> (char[] buffer, int start, int length)</td></tr>
<tr class="memdesc:a13b5828d33ea1400e49c1efd48a31de8 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads <a class="el" href="namespace_lucene.html">Lucene</a>'s old "modified UTF-8" encoded characters into an array.  <a href="#a13b5828d33ea1400e49c1efd48a31de8"></a><br/></td></tr>
<tr class="separator:a13b5828d33ea1400e49c1efd48a31de8 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a13343c201d95a9dfaa47c067e9b89c9c inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a13343c201d95a9dfaa47c067e9b89c9c">SkipChars</a> (int length)</td></tr>
<tr class="memdesc:a13343c201d95a9dfaa47c067e9b89c9c inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Expert  <a href="#a13343c201d95a9dfaa47c067e9b89c9c"></a><br/></td></tr>
<tr class="separator:a13343c201d95a9dfaa47c067e9b89c9c inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a574f688ef9a010b1d8d1ba8c37926ce7 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><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_store_1_1_index_input.html#a574f688ef9a010b1d8d1ba8c37926ce7">Close</a> ()</td></tr>
<tr class="separator:a574f688ef9a010b1d8d1ba8c37926ce7 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7b47f54e3905080834cb211adb00bf06 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><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_store_1_1_index_input.html#a7b47f54e3905080834cb211adb00bf06">Dispose</a> ()</td></tr>
<tr class="memdesc:a7b47f54e3905080834cb211adb00bf06 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Closes the stream to futher operations.  <a href="#a7b47f54e3905080834cb211adb00bf06"></a><br/></td></tr>
<tr class="separator:a7b47f54e3905080834cb211adb00bf06 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a43cf88393d46a09ee267e0d709631258 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">abstract long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a43cf88393d46a09ee267e0d709631258">Length</a> ()</td></tr>
<tr class="memdesc:a43cf88393d46a09ee267e0d709631258 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">The number of bytes in the file.  <a href="#a43cf88393d46a09ee267e0d709631258"></a><br/></td></tr>
<tr class="separator:a43cf88393d46a09ee267e0d709631258 inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7c7e3dd310f0c7100cad9cd00b19c3bf inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">virtual <br class="typebreak"/>
System.Collections.Generic.IDictionary<br class="typebreak"/>
&lt; string, string &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a7c7e3dd310f0c7100cad9cd00b19c3bf">ReadStringStringMap</a> ()</td></tr>
<tr class="separator:a7c7e3dd310f0c7100cad9cd00b19c3bf inherit pub_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
Public Attributes</h2></td></tr>
<tr class="memitem:a57f50895a77d1f3942afac4a1df5a393"><td class="memItemLeft" align="right" valign="top">const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a57f50895a77d1f3942afac4a1df5a393">BUFFER_SIZE</a> = 1024</td></tr>
<tr class="memdesc:a57f50895a77d1f3942afac4a1df5a393"><td class="mdescLeft">&#160;</td><td class="mdescRight">Default buffer size  <a href="#a57f50895a77d1f3942afac4a1df5a393"></a><br/></td></tr>
<tr class="separator:a57f50895a77d1f3942afac4a1df5a393"><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:a36860af3edc5070bf23f5f1fd589c476"><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_store_1_1_buffered_index_input.html#a36860af3edc5070bf23f5f1fd589c476">BufferedIndexInput</a> ()</td></tr>
<tr class="separator:a36860af3edc5070bf23f5f1fd589c476"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a66d4a75335786e4cf831e227c9ba88c4"><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_store_1_1_buffered_index_input.html#a66d4a75335786e4cf831e227c9ba88c4">BufferedIndexInput</a> (int bufferSize)</td></tr>
<tr class="memdesc:a66d4a75335786e4cf831e227c9ba88c4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Inits <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html" title="Base implementation class for buffered IndexInput. ">BufferedIndexInput</a> with a specific bufferSize  <a href="#a66d4a75335786e4cf831e227c9ba88c4"></a><br/></td></tr>
<tr class="separator:a66d4a75335786e4cf831e227c9ba88c4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pro_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_class_lucene_1_1_net_1_1_store_1_1_index_input')"><img src="closed.png" alt="-"/>&#160;Protected Member Functions inherited from <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html">Lucene.Net.Store.IndexInput</a></td></tr>
<tr class="memitem:aad5ca633baa83bd8b7486586b3a799a7 inherit pro_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">abstract void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#aad5ca633baa83bd8b7486586b3a799a7">Dispose</a> (bool disposing)</td></tr>
<tr class="separator:aad5ca633baa83bd8b7486586b3a799a7 inherit pro_methods_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="properties"></a>
Properties</h2></td></tr>
<tr class="memitem:aa08929b972c6598f159819db738198cd"><td class="memItemLeft" align="right" valign="top">virtual int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#aa08929b972c6598f159819db738198cd">BufferSize</a><code> [get]</code></td></tr>
<tr class="separator:aa08929b972c6598f159819db738198cd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0c7dc4d8cb466311840a83265c5baafa"><td class="memItemLeft" align="right" valign="top">override long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a0c7dc4d8cb466311840a83265c5baafa">FilePointer</a><code> [get]</code></td></tr>
<tr class="separator:a0c7dc4d8cb466311840a83265c5baafa"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_class_lucene_1_1_net_1_1_store_1_1_index_input"><td colspan="2" onclick="javascript:toggleInherit('properties_class_lucene_1_1_net_1_1_store_1_1_index_input')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html">Lucene.Net.Store.IndexInput</a></td></tr>
<tr class="memitem:a9ad391d8d7734d1cb5dd0c0faadb6fe2 inherit properties_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="memItemLeft" align="right" valign="top">abstract long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a9ad391d8d7734d1cb5dd0c0faadb6fe2">FilePointer</a><code> [get]</code></td></tr>
<tr class="memdesc:a9ad391d8d7734d1cb5dd0c0faadb6fe2 inherit properties_class_lucene_1_1_net_1_1_store_1_1_index_input"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the current position in this file, where the next read will occur.  <a href="#a9ad391d8d7734d1cb5dd0c0faadb6fe2"></a><br/></td></tr>
<tr class="separator:a9ad391d8d7734d1cb5dd0c0faadb6fe2 inherit properties_class_lucene_1_1_net_1_1_store_1_1_index_input"><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>Base implementation class for buffered <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html" title="Abstract base class for input from a file in a Directory. A random-access input stream. Used for all Lucene index input operations. ">IndexInput</a>. </p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00024">24</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>
</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<a class="anchor" id="a36860af3edc5070bf23f5f1fd589c476"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">Lucene.Net.Store.BufferedIndexInput.BufferedIndexInput </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">protected</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00045">45</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<a class="anchor" id="a66d4a75335786e4cf831e227c9ba88c4"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">Lucene.Net.Store.BufferedIndexInput.BufferedIndexInput </td>
          <td>(</td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>bufferSize</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">protected</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Inits <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html" title="Base implementation class for buffered IndexInput. ">BufferedIndexInput</a> with a specific bufferSize </p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00050">50</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<h2 class="groupheader">Member Function Documentation</h2>
<a class="anchor" id="a2af4a6df705c09aeebdd8cc580dc4b30"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override System.Object Lucene.Net.Store.BufferedIndexInput.Clone </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns a clone of this stream. </p>
<p>Clones of a stream access the same data, and are positioned at the same point as the stream they were cloned from.</p>
<p>Expert: Subclasses must ensure that clones may be positioned at different points in the input from each other and from the stream they were cloned from. </p>

<p>Reimplemented from <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#ad9135bbc652f8bab34b802ba334af467">Lucene.Net.Store.IndexInput</a>.</p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00229">229</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<a class="anchor" id="a9b246c7d1caa549dfe3c845b422d7493"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override byte Lucene.Net.Store.BufferedIndexInput.ReadByte </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reads and returns a single byte.</p>
<dl class="section see"><dt>See Also</dt><dd><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_output.html#a32212df800586332f916005eb5e33ae4" title="Writes a single byte.">IndexOutput.WriteByte(byte)</a></dd></dl>

<p>Implements <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#ad6f939ef2662e50575bc091c181ae017">Lucene.Net.Store.IndexInput</a>.</p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00038">38</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<a class="anchor" id="ab72a40d6c16cd5c3d4e5919ac1279ffe"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override void Lucene.Net.Store.BufferedIndexInput.ReadBytes </td>
          <td>(</td>
          <td class="paramtype">byte[]&#160;</td>
          <td class="paramname"><em>b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>offset</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>len</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reads a specified number of bytes into an array at the specified offset.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">b</td><td>the array to read bytes into </td></tr>
    <tr><td class="paramname">offset</td><td>the offset in the array to start storing bytes </td></tr>
    <tr><td class="paramname">len</td><td>the number of bytes to read </td></tr>
  </table>
  </dd>
</dl>
<dl class="section see"><dt>See Also</dt><dd><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_output.html#a448d0b65b5cf770a0326ebe63f1532b2" title="Writes an array of bytes.">IndexOutput.WriteBytes(byte[],int)</a></dd></dl>

<p>Implements <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a428913bea51c264523f8c6cecba321e3">Lucene.Net.Store.IndexInput</a>.</p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00104">104</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<a class="anchor" id="a46d25b8c06552053cd0aff8a123e6cfd"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override void Lucene.Net.Store.BufferedIndexInput.ReadBytes </td>
          <td>(</td>
          <td class="paramtype">byte[]&#160;</td>
          <td class="paramname"><em>b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>offset</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>len</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>useBuffer</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reads a specified number of bytes into an array at the specified offset with control over whether the read should be buffered (callers who have their own buffer should pass in "false" for useBuffer). Currently only <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html" title="Base implementation class for buffered IndexInput. ">BufferedIndexInput</a> respects this parameter. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">b</td><td>the array to read bytes into </td></tr>
    <tr><td class="paramname">offset</td><td>the offset in the array to start storing bytes </td></tr>
    <tr><td class="paramname">len</td><td>the number of bytes to read </td></tr>
    <tr><td class="paramname">useBuffer</td><td>set to false if the caller will handle buffering. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section see"><dt>See Also</dt><dd><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_output.html#a448d0b65b5cf770a0326ebe63f1532b2" title="Writes an array of bytes.">IndexOutput.WriteBytes(byte[],int)</a></dd></dl>

<p>Reimplemented from <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a1bfd87b57bdb9fc97b933aa43004b906">Lucene.Net.Store.IndexInput</a>.</p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00109">109</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<a class="anchor" id="a6178a13660e773df6b0091d4189a6f66"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract void Lucene.Net.Store.BufferedIndexInput.ReadInternal </td>
          <td>(</td>
          <td class="paramtype">byte[]&#160;</td>
          <td class="paramname"><em>b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>offset</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>length</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Expert: implements buffer refill. Reads bytes from the current position in the input. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">b</td><td>the array to read bytes into </td></tr>
    <tr><td class="paramname">offset</td><td>the offset in the array to start storing bytes </td></tr>
    <tr><td class="paramname">length</td><td>the number of bytes to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a7e9a8492f0572972e2b41bc4f1121166"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override void Lucene.Net.Store.BufferedIndexInput.Seek </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>pos</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sets current position in this file, where the next read will occur.</p>
<dl class="section see"><dt>See Also</dt><dd><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a0c7dc4d8cb466311840a83265c5baafa">FilePointer</a></dd></dl>

<p>Implements <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html#a3076d1786475e769c8e094f3342a3b92">Lucene.Net.Store.IndexInput</a>.</p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00208">208</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<a class="anchor" id="abd28d53004637abdea59552bdf870625"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract void Lucene.Net.Store.BufferedIndexInput.SeekInternal </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>pos</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Expert: implements seek. Sets current position in this file, where the next <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a6178a13660e773df6b0091d4189a6f66" title="Expert: implements buffer refill. Reads bytes from the current position in the input. ">ReadInternal(byte[],int,int)</a> will occur. </p>
<dl class="section see"><dt>See Also</dt><dd><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#a6178a13660e773df6b0091d4189a6f66" title="Expert: implements buffer refill. Reads bytes from the current position in the input. ">ReadInternal(byte[],int,int)</a></dd></dl>

</div>
</div>
<a class="anchor" id="afb59e7f3d587cf2aeefe41da40ea7278"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">virtual void Lucene.Net.Store.BufferedIndexInput.SetBufferSize </td>
          <td>(</td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>newSize</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Change the buffer size used by this <a class="el" href="class_lucene_1_1_net_1_1_store_1_1_index_input.html" title="Abstract base class for input from a file in a Directory. A random-access input stream. Used for all Lucene index input operations. ">IndexInput</a> </p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00057">57</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<h2 class="groupheader">Member Data Documentation</h2>
<a class="anchor" id="a57f50895a77d1f3942afac4a1df5a393"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">const int Lucene.Net.Store.BufferedIndexInput.BUFFER_SIZE = 1024</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Default buffer size </p>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00028">28</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<h2 class="groupheader">Property Documentation</h2>
<a class="anchor" id="aa08929b972c6598f159819db738198cd"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">virtual int Lucene.Net.Store.BufferedIndexInput.BufferSize</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">
<dl class="section see"><dt>See Also</dt><dd><a class="el" href="class_lucene_1_1_net_1_1_store_1_1_buffered_index_input.html#afb59e7f3d587cf2aeefe41da40ea7278" title="Change the buffer size used by this IndexInput ">SetBufferSize</a></dd></dl>

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00094">94</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

</div>
</div>
<a class="anchor" id="a0c7dc4d8cb466311840a83265c5baafa"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">override long Lucene.Net.Store.BufferedIndexInput.FilePointer</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Definition at line <a class="el" href="_buffered_index_input_8cs_source.html#l00204">204</a> of file <a class="el" href="_buffered_index_input_8cs_source.html">BufferedIndexInput.cs</a>.</p>

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