RAMDirectory.cs
上传用户:zhangkuixh
上传日期:2013-09-30
资源大小:5473k
文件大小:7k
源码类别:

搜索引擎

开发平台:

C#

  1. /*
  2.  * Copyright 2004 The Apache Software Foundation
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. using System;
  17. namespace Lucene.Net.Store
  18. {
  19. /// <summary> A memory-resident {@link Directory} implementation.
  20. /// 
  21. /// </summary>
  22. /// <version>  $Id: RAMDirectory.java 351779 2005-12-02 17:37:50Z bmesser $
  23. /// </version>
  24. public sealed class RAMDirectory : Directory
  25. {
  26. private class AnonymousClassLock : Lock
  27. {
  28. public AnonymousClassLock(System.String name, RAMDirectory enclosingInstance)
  29. {
  30. InitBlock(name, enclosingInstance);
  31. }
  32. private void  InitBlock(System.String name, RAMDirectory enclosingInstance)
  33. {
  34. this.name = name;
  35. this.enclosingInstance = enclosingInstance;
  36. }
  37. private System.String name;
  38. private RAMDirectory enclosingInstance;
  39. public RAMDirectory Enclosing_Instance
  40. {
  41. get
  42. {
  43. return enclosingInstance;
  44. }
  45. }
  46. public override bool Obtain()
  47. {
  48. lock (Enclosing_Instance.files.SyncRoot)
  49. {
  50. if (!Enclosing_Instance.FileExists(name))
  51. {
  52. Enclosing_Instance.CreateOutput(name).Close();
  53. return true;
  54. }
  55. return false;
  56. }
  57. }
  58. public override void  Release()
  59. {
  60. Enclosing_Instance.DeleteFile(name);
  61. }
  62. public override bool IsLocked()
  63. {
  64. return Enclosing_Instance.FileExists(name);
  65. }
  66. }
  67. internal System.Collections.Hashtable files = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
  68. /// <summary>Constructs an empty {@link Directory}. </summary>
  69. public RAMDirectory()
  70. {
  71. }
  72. /// <summary> Creates a new <code>RAMDirectory</code> instance from a different
  73. /// <code>Directory</code> implementation.  This can be used to load
  74. /// a disk-based index into memory.
  75. /// <P>
  76. /// This should be used only with indices that can fit into memory.
  77. /// 
  78. /// </summary>
  79. /// <param name="dir">a <code>Directory</code> value
  80. /// </param>
  81. /// <exception cref="IOException">if an error occurs
  82. /// </exception>
  83. public RAMDirectory(Directory dir):this(dir, false)
  84. {
  85. }
  86. private RAMDirectory(Directory dir, bool closeDir)
  87. {
  88. System.String[] files = dir.List();
  89. byte[] buf = new byte[BufferedIndexOutput.BUFFER_SIZE];
  90. for (int i = 0; i < files.Length; i++)
  91. {
  92. // make place on ram disk
  93. IndexOutput os = CreateOutput(System.IO.Path.GetFileName(files[i]));
  94. // read current file
  95. IndexInput is_Renamed = dir.OpenInput(files[i]);
  96. // and copy to ram disk
  97. int len = (int) is_Renamed.Length();
  98. int readCount = 0;
  99. while (readCount < len)
  100. {
  101. int toRead = readCount + BufferedIndexOutput.BUFFER_SIZE > len?len - readCount:BufferedIndexOutput.BUFFER_SIZE;
  102. is_Renamed.ReadBytes(buf, 0, toRead);
  103. os.WriteBytes(buf, toRead);
  104. readCount += toRead;
  105. }
  106. // graceful cleanup
  107. is_Renamed.Close();
  108. os.Close();
  109. }
  110. if (closeDir)
  111. dir.Close();
  112. }
  113. /// <summary> Creates a new <code>RAMDirectory</code> instance from the {@link FSDirectory}.
  114. /// 
  115. /// </summary>
  116. /// <param name="dir">a <code>File</code> specifying the index directory
  117. /// </param>
  118. public RAMDirectory(System.IO.FileInfo dir) : this(FSDirectory.GetDirectory(dir, false), true)
  119. {
  120. }
  121. /// <summary> Creates a new <code>RAMDirectory</code> instance from the {@link FSDirectory}.
  122. /// 
  123. /// </summary>
  124. /// <param name="dir">a <code>String</code> specifying the full index directory path
  125. /// </param>
  126. public RAMDirectory(System.String dir) : this(FSDirectory.GetDirectory(dir, false), true)
  127. {
  128. }
  129. /// <summary>Returns an array of strings, one for each file in the directory. </summary>
  130. public override System.String[] List()
  131. {
  132. System.String[] result = new System.String[files.Count];
  133. int i = 0;
  134. System.Collections.IEnumerator names = files.Keys.GetEnumerator();
  135. while (names.MoveNext())
  136. {
  137. result[i++] = ((System.String) names.Current);
  138. }
  139. return result;
  140. }
  141. /// <summary>Returns true iff the named file exists in this directory. </summary>
  142. public override bool FileExists(System.String name)
  143. {
  144. RAMFile file = (RAMFile) files[name];
  145. return file != null;
  146. }
  147. /// <summary>Returns the time the named file was last modified. </summary>
  148. public override long FileModified(System.String name)
  149. {
  150. RAMFile file = (RAMFile) files[name];
  151. return file.lastModified;
  152. }
  153. /// <summary>Set the modified time of an existing file to now. </summary>
  154. public override void  TouchFile(System.String name)
  155. {
  156. //     final boolean MONITOR = false;
  157. RAMFile file = (RAMFile) files[name];
  158. long ts2, ts1 = System.DateTime.Now.Ticks;
  159. do 
  160. {
  161. try
  162. {
  163. System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * 0 + 100 * 1));
  164. }
  165. catch (System.Threading.ThreadInterruptedException)
  166. {
  167. }
  168. ts2 = System.DateTime.Now.Ticks;
  169. //       if (MONITOR) {
  170. //         count++;
  171. //       }
  172. }
  173. while (ts1 == ts2);
  174. file.lastModified = ts2;
  175. //     if (MONITOR)
  176. //         System.out.println("SLEEP COUNT: " + count);
  177. }
  178. /// <summary>Returns the length in bytes of a file in the directory. </summary>
  179. public override long FileLength(System.String name)
  180. {
  181. RAMFile file = (RAMFile) files[name];
  182. return file.length;
  183. }
  184. /// <summary>Removes an existing file in the directory. </summary>
  185. public override void  DeleteFile(System.String name)
  186. {
  187. files.Remove(name);
  188. }
  189. /// <summary>Removes an existing file in the directory. </summary>
  190. public override void  RenameFile(System.String from, System.String to)
  191. {
  192. RAMFile file = (RAMFile) files[from];
  193. files.Remove(from);
  194. files[to] = file;
  195. }
  196. /// <summary>Creates a new, empty file in the directory with the given name.
  197. /// Returns a stream writing this file. 
  198. /// </summary>
  199. public override IndexOutput CreateOutput(System.String name)
  200. {
  201. RAMFile file = new RAMFile();
  202. files[name] = file;
  203. return new RAMOutputStream(file);
  204. }
  205. /// <summary>Returns a stream reading an existing file. </summary>
  206. public override IndexInput OpenInput(System.String name)
  207. {
  208. RAMFile file = (RAMFile) files[name];
  209. return new RAMInputStream(file);
  210. }
  211. /// <summary>Construct a {@link Lock}.</summary>
  212. /// <param name="name">the name of the lock file
  213. /// </param>
  214. public override Lock MakeLock(System.String name)
  215. {
  216. return new AnonymousClassLock(name, this);
  217. }
  218. /// <summary>Closes the store to future operations. </summary>
  219. public override void  Close()
  220. {
  221. }
  222. }
  223. }