Directory.cs

Go to the documentation of this file.

/* 
 * 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;

using IndexFileNameFilter = Lucene.Net.Index.IndexFileNameFilter;

namespace Lucene.Net.Store
{
    
    [Serializable]
    public abstract class Directory : System.IDisposable
    {
        protected internal volatile bool isOpen = true;
        
        [NonSerialized]
        protected internal LockFactory interalLockFactory;

        public abstract System.String[] ListAll();
        
        public abstract bool FileExists(System.String name);
        
        public abstract long FileModified(System.String name);
        
        public abstract void TouchFile(System.String name);
        
        public abstract void  DeleteFile(System.String name);
        
        public abstract long FileLength(System.String name);
        
        
        public abstract IndexOutput CreateOutput(System.String name);
        
        public virtual void  Sync(System.String name)
        {
        }
        
        public abstract IndexInput OpenInput(System.String name);
        
        public virtual IndexInput OpenInput(System.String name, int bufferSize)
        {
            return OpenInput(name);
        }
        
        public virtual Lock MakeLock(System.String name)
        {
            return interalLockFactory.MakeLock(name);
        }
        public virtual void  ClearLock(System.String name)
        {
            if (interalLockFactory != null)
            {
                interalLockFactory.ClearLock(name);
            }
        }
        
        [Obsolete("Use Dispose() instead")]
        public void Close()
        {
            Dispose();
        }

        public void Dispose()
        {
            Dispose(true);
        }

        protected abstract void Dispose(bool disposing);

        public virtual void  SetLockFactory(LockFactory lockFactory)
        {
            System.Diagnostics.Debug.Assert(lockFactory != null);
            this.interalLockFactory = lockFactory;
            lockFactory.LockPrefix = this.GetLockId();
        }

        public virtual LockFactory LockFactory
        {
            get { return this.interalLockFactory; }
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
        public virtual string GetLockId()
        {
            return ToString();
        }

        public override string ToString()
        {
            return base.ToString() + " lockFactory=" + LockFactory;
        }
        
        public static void  Copy(Directory src, Directory dest, bool closeDirSrc)
        {
            System.String[] files = src.ListAll();
            
            IndexFileNameFilter filter = IndexFileNameFilter.Filter;
            
            byte[] buf = new byte[BufferedIndexOutput.BUFFER_SIZE];
            for (int i = 0; i < files.Length; i++)
            {
                
                if (!filter.Accept(null, files[i]))
                    continue;
                
                IndexOutput os = null;
                IndexInput is_Renamed = null;
                try
                {
                    // create file in dest directory
                    os = dest.CreateOutput(files[i]);
                    // read current file
                    is_Renamed = src.OpenInput(files[i]);
                    // and copy to dest directory
                    long len = is_Renamed.Length();
                    long readCount = 0;
                    while (readCount < len)
                    {
                        int toRead = readCount + BufferedIndexOutput.BUFFER_SIZE > len?(int) (len - readCount):BufferedIndexOutput.BUFFER_SIZE;
                        is_Renamed.ReadBytes(buf, 0, toRead);
                        os.WriteBytes(buf, toRead);
                        readCount += toRead;
                    }
                }
                finally
                {
                    // graceful cleanup
                    try
                    {
                        if (os != null)
                            os.Close();
                    }
                    finally
                    {
                        if (is_Renamed != null)
                            is_Renamed.Close();
                    }
                }
            }
            if (closeDirSrc)
                src.Close();
        }
        
        public /*protected internal*/ void  EnsureOpen()
        {
            if (!isOpen)
                throw new AlreadyClosedException("this Directory is closed");
        }

        public bool isOpen_ForNUnit
        {
            get { return isOpen; }
        }
    }
}