mcs/tools/monkeydoc/Lucene.Net/Lucene.Net/Store/SingleInstanceLockFactory.cs

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 using System;
  19
  20 namespace Mono.Lucene.Net.Store
  21 {
  22
  23         /// <summary> Implements {@link LockFactory} for a single in-process instance,
  24         /// meaning all locking will take place through this one instance.
  25         /// Only use this {@link LockFactory} when you are certain all
  26         /// IndexReaders and IndexWriters for a given index are running
  27         /// against a single shared in-process Directory instance.  This is
  28         /// currently the default locking for RAMDirectory.
  29         ///
  30         /// </summary>
  31         /// <seealso cref="LockFactory">
  32         /// </seealso>
  33
  34         public class SingleInstanceLockFactory:LockFactory
  35         {
  36
  37         private System.Collections.Hashtable locks = new System.Collections.Hashtable();
  38
  39                 public override Lock MakeLock(System.String lockName)
  40                 {
  41                         // We do not use the LockPrefix at all, because the private
  42                         // HashSet instance effectively scopes the locking to this
  43                         // single Directory instance.
  44                         return new SingleInstanceLock(locks, lockName);
  45                 }
  46
  47                 public override void  ClearLock(System.String lockName)
  48                 {
  49                         lock (locks)
  50                         {
  51                                 if (locks.Contains(lockName))
  52                                 {
  53                                         locks.Remove(lockName);
  54                                 }
  55                         }
  56                 }
  57         }
  58
  59
  60         class SingleInstanceLock:Lock
  61         {
  62
  63                 internal System.String lockName;
  64                 private System.Collections.Hashtable locks;
  65
  66                 public SingleInstanceLock(System.Collections.Hashtable locks, System.String lockName)
  67                 {
  68                         this.locks = locks;
  69                         this.lockName = lockName;
  70                 }
  71
  72                 public override bool Obtain()
  73                 {
  74                         lock (locks)
  75                         {
  76                 if (locks.Contains(lockName) == false)
  77                 {
  78                     locks.Add(lockName, lockName);
  79                     return true;
  80                 }
  81
  82                 return false;
  83                         }
  84                 }
  85
  86                 public override void  Release()
  87                 {
  88                         lock (locks)
  89                         {
  90                                 locks.Remove(lockName);
  91                         }
  92                 }
  93
  94                 public override bool IsLocked()
  95                 {
  96                         lock (locks)
  97                         {
  98                                 return locks.Contains(lockName);
  99                         }
 100                 }
 101
 102                 public override System.String ToString()
 103                 {
 104                         return base.ToString() + ": " + lockName;
 105                 }
 106         }
 107 }