/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
namespace Lucene.Net.Store
{
/// A memory-resident {@link Directory} implementation. Locking
/// implementation is by default the {@link SingleInstanceLockFactory}
/// but can be changed with {@link #setLockFactory}.
///
///
/// $Id: RAMDirectory.java 503911 2007-02-05 22:49:42Z dnaber $
///
[Serializable]
public class RAMDirectory : Directory
{
private const long serialVersionUID = 1L;
internal System.Collections.Hashtable fileMap = new System.Collections.Hashtable();
internal long sizeInBytes = 0;
public System.Collections.Hashtable fileMap_ForNUnitTest
{
get { return fileMap; }
}
public long sizeInBytes_ForNUnitTest
{
get { return sizeInBytes; }
set { sizeInBytes = value; }
}
// *****
// Lock acquisition sequence: RAMDirectory, then RAMFile
// *****
/// Constructs an empty {@link Directory}.
public RAMDirectory()
{
SetLockFactory(new SingleInstanceLockFactory());
}
/// Creates a new RAMDirectory instance from a different
/// Directory implementation. This can be used to load
/// a disk-based index into memory.
///
/// This should be used only with indices that can fit into memory.
///
/// Note that the resulting RAMDirectory instance is fully
/// independent from the original Directory (it is a
/// complete copy). Any subsequent changes to the
/// original Directory will not be visible in the
/// RAMDirectory instance.
///
///
/// a Directory value
///
/// IOException if an error occurs
///
public RAMDirectory(Directory dir):this(dir, false)
{
}
private RAMDirectory(Directory dir, bool closeDir):this()
{
Directory.Copy(dir, this, closeDir);
}
/// Creates a new RAMDirectory instance from the {@link FSDirectory}.
///
///
/// a File specifying the index directory
///
///
///
///
public RAMDirectory(System.IO.FileInfo dir):this(FSDirectory.GetDirectory(dir), true)
{
}
/// Creates a new RAMDirectory instance from the {@link FSDirectory}.
///
///
/// a String specifying the full index directory path
///
///
///
///
public RAMDirectory(System.String dir) : this(FSDirectory.GetDirectory(dir), true)
{
}
/// Returns an array of strings, one for each file in the directory.
public override System.String[] List()
{
lock (this)
{
System.String[] result = new System.String[fileMap.Count];
int i = 0;
System.Collections.IEnumerator it = fileMap.Keys.GetEnumerator();
while (it.MoveNext())
{
result[i++] = ((System.String) it.Current);
}
return result;
}
}
/// Returns true iff the named file exists in this directory.
public override bool FileExists(System.String name)
{
RAMFile file;
lock (this)
{
file = (RAMFile) fileMap[name];
}
return file != null;
}
/// Returns the time the named file was last modified.
/// IOException if the file does not exist
public override long FileModified(System.String name)
{
RAMFile file;
lock (this)
{
file = (RAMFile) fileMap[name];
}
if (file == null)
throw new System.IO.FileNotFoundException(name);
return file.GetLastModified();
}
/// Set the modified time of an existing file to now.
/// IOException if the file does not exist
public override void TouchFile(System.String name)
{
RAMFile file;
lock (this)
{
file = (RAMFile) fileMap[name];
}
if (file == null)
throw new System.IO.FileNotFoundException(name);
long ts2, ts1 = System.DateTime.Now.Ticks;
do
{
try
{
System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * 0 + 100 * 1));
}
catch (System.Threading.ThreadInterruptedException)
{
}
ts2 = System.DateTime.Now.Ticks;
}
while (ts1 == ts2);
file.SetLastModified(ts2);
}
/// Returns the length in bytes of a file in the directory.
/// IOException if the file does not exist
public override long FileLength(System.String name)
{
RAMFile file;
lock (this)
{
file = (RAMFile) fileMap[name];
}
if (file == null)
throw new System.IO.FileNotFoundException(name);
return file.GetLength();
}
/// Return total size in bytes of all files in this
/// directory. This is currently quantized to
/// BufferedIndexOutput.BUFFER_SIZE.
///
public long SizeInBytes()
{
lock (this)
{
return sizeInBytes;
}
}
/// Removes an existing file in the directory.
/// IOException if the file does not exist
public override void DeleteFile(System.String name)
{
lock (this)
{
RAMFile file = (RAMFile) fileMap[name];
if (file != null)
{
fileMap.Remove(name);
file.directory = null;
sizeInBytes -= file.sizeInBytes; // updates to RAMFile.sizeInBytes synchronized on directory
}
else
throw new System.IO.FileNotFoundException(name);
}
}
/// Renames an existing file in the directory.
/// FileNotFoundException if from does not exist
///
///
public override void RenameFile(System.String from, System.String to)
{
lock (this)
{
RAMFile fromFile = (RAMFile) fileMap[from];
if (fromFile == null)
throw new System.IO.FileNotFoundException(from);
RAMFile toFile = (RAMFile) fileMap[to];
if (toFile != null)
{
sizeInBytes -= toFile.sizeInBytes; // updates to RAMFile.sizeInBytes synchronized on directory
toFile.directory = null;
}
fileMap.Remove(from);
fileMap[to] = fromFile;
}
}
/// Creates a new, empty file in the directory with the given name. Returns a stream writing this file.
public override IndexOutput CreateOutput(System.String name)
{
RAMFile file = new RAMFile(this);
lock (this)
{
RAMFile existing = (RAMFile) fileMap[name];
if (existing != null)
{
sizeInBytes -= existing.sizeInBytes;
existing.directory = null;
}
fileMap[name] = file;
}
return new RAMOutputStream(file);
}
/// Returns a stream reading an existing file.
public override IndexInput OpenInput(System.String name)
{
RAMFile file;
lock (this)
{
file = (RAMFile) fileMap[name];
}
if (file == null)
throw new System.IO.FileNotFoundException(name);
return new RAMInputStream(file);
}
/// Closes the store to future operations, releasing associated memory.
public override void Close()
{
fileMap = null;
}
}
}