public void Add(ILockable lockable) { if(locked) lockable.Lock(); lockables.Add(lockable); }
public LockHandle Lock(ILockable[] toWrite, ILockable[] toRead, LockingMode mode) { // Set up the local constants. int lockCount = toRead.Length + toWrite.Length; LockHandle handle = new LockHandle(lockCount); lock (this) { Lock @lock; LockingQueue queue; // Add Read and Write locks to cache and to the handle. for (int i = toWrite.Length - 1; i >= 0; --i) { var toWriteLock = toWrite[i]; queue = GetQueueFor(toWriteLock); // slightly confusing: this will add Lock to given table queue @lock = new Lock(queue, mode, AccessType.Write); @lock.Acquire(); handle.AddLock(@lock); } for (int i = toRead.Length - 1; i >= 0; --i) { var toReadLock = toRead[i]; queue = GetQueueFor(toReadLock); // slightly confusing: this will add Lock to given table queue @lock = new Lock(queue, mode, AccessType.Read); @lock.Acquire(); handle.AddLock(@lock); } } return handle; }
public void Dispose() { if(lockable == null) return; lockable.Unlock(); lockable = null; }
public bool IsHandled(ILockable lockable) { for (int i = locks.Length - 1; i >= 0; i--) { if (locks[i].Lockable.RefId.Equals(lockable.RefId)) return true; } return false; }
public bool IsLocked(ILockable lockable) { lock (this) { LockingQueue queue; if (!queuesMap.TryGetValue(lockable.RefId, out queue)) return false; return !queue.IsEmpty; } }
public void CheckAccess(ILockable[] lockables, AccessType accessType, int timeout) { if (openHandles == null || lockables == null) return; foreach (var handle in openHandles) { foreach (var lockable in lockables) { if (handle.IsHandled(lockable)) handle.CheckAccess(lockable, accessType, timeout); } } }
/// <summary> /// Do not return an item whose timestamp is later than the current /// transaction timestamp. (Otherwise we might compromise repeatable /// read unnecessarily.) Do not return an item which is soft-locked. /// Always go straight to the database instead. /// </summary> /// <remarks> /// Note that since reading an item from that cache does not actually /// go to the database, it is possible to see a kind of phantom read /// due to the underlying row being updated after we have read it /// from the cache. This would not be possible in a lock-based /// implementation of repeatable read isolation. It is also possible /// to overwrite changes made and committed by another transaction /// after the current transaction read the item from the cache. This /// problem would be caught by the update-time version-checking, if /// the data is versioned or timestamped. /// </remarks> public async Task <object> GetAsync(CacheKey key, long txTimestamp, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _lockObjectAsync.LockAsync()) { if (log.IsDebugEnabled()) { log.Debug("Cache lookup: {0}", key); } // commented out in H3.1 /*try * { * cache.Lock( key );*/ ILockable lockable = (ILockable)await(Cache.GetAsync(key, cancellationToken)).ConfigureAwait(false); bool gettable = lockable != null && lockable.IsGettable(txTimestamp); if (gettable) { if (log.IsDebugEnabled()) { log.Debug("Cache hit: {0}", key); } return(((CachedItem)lockable).Value); } else { if (log.IsDebugEnabled()) { if (lockable == null) { log.Debug("Cache miss: {0}", key); } else { log.Debug("Cached item was locked: {0}", key); } } return(null); } /*} * finally * { * cache.Unlock( key ); * }*/ } }
public TableAndLockProvider GetStateProvider(String tableName, int agentInstanceId, bool writesToTables) { TableStateInstance instance = AssertGetState(tableName, agentInstanceId); ILockable @lock = writesToTables ? instance.TableLevelRWLock.WriteLock : instance.TableLevelRWLock.ReadLock; if (instance is TableStateInstanceGrouped) { return new TableAndLockProviderGroupedImpl(new TableAndLockGrouped(@lock, (TableStateInstanceGrouped)instance)); } else { return new TableAndLockProviderUngroupedImpl(new TableAndLockUngrouped(@lock, (TableStateInstanceUngrouped)instance)); } }
public TimeWinRunnable( int threadNum, RegressionEnvironment env, ILockable sharedLock, string[] symbols, int numberOfEvents) { this.threadNum = threadNum; this.env = env; this.sharedLock = sharedLock; this.symbols = symbols; this.numberOfEvents = numberOfEvents; }
/// <summary> /// Close an object /// </summary> public static void Close(ILockable lockable, Character user) { if (lockable is GameObject) { var go = lockable as GameObject; go.State = GameObjectState.Disabled; if (go.Map is Battleground) { Battleground bg = go.Map as Battleground; bg.OnPlayerClickedOnflag(go, user); } } }
/// <summary> /// Open a GameObject /// </summary> public static void Open(ILockable lockable, Character chr) { if (lockable is GameObject) { var go = lockable as GameObject; go.Use(chr); if (go.Map is Battleground) { var bg = go.Map as Battleground; bg.OnPlayerClickedOnflag(go, chr); } } }
/// <summary> /// Ctor. /// </summary> /// <param name="runtime">for processing events</param> /// <param name="beanEventType">the event type</param> /// <param name="eventAdapterService">factory for event beans and event types</param> /// <param name="threadingService">for inbound threading</param> public EventSenderBean( EPRuntimeEventSender runtime, BeanEventType beanEventType, EventAdapterService eventAdapterService, ThreadingService threadingService) { _iLock = LockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); _runtime = runtime; _beanEventType = beanEventType; _eventAdapterService = eventAdapterService; _compatibleClasses = new HashSet <Type>(); _threadingService = threadingService; }
static void EndPopulate(IList target, ISupportInitialize supportInitialize) { ILockable lockable = target as ILockable; if (lockable != null) { lockable.EndUpdate(); } if (supportInitialize != null) { supportInitialize.EndInit(); } }
static void BeginPopulate(IList target, ISupportInitialize supportInitialize) { if (supportInitialize != null) { supportInitialize.BeginInit(); } ILockable lockable = target as ILockable; if (lockable != null) { lockable.BeginUpdate(); } }
/// <summary> /// Ctor. /// </summary> /// <param name="lockManager">The lock manager.</param> /// <param name="eventAdapterService">for dynamic event type creation</param> /// <param name="metadata">event type metadata</param> /// <param name="eventTypeId">The event type id.</param> /// <param name="underlyngType">is the underlying type returned by the event type</param> protected BaseConfigurableEventType( ILockManager lockManager, EventAdapterService eventAdapterService, EventTypeMetadata metadata, int eventTypeId, Type underlyngType) { _iLock = lockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); _eventTypeId = eventTypeId; _eventAdapterService = eventAdapterService; _metadata = metadata; _underlyngType = underlyngType; }
/// <summary> /// Adds the acquired lock. If the lock does not already belong to the context, then it will be locked and /// the disposable lock will be returned. /// </summary> /// <param name="lock">The lock.</param> /// <returns></returns> public IDisposable AddAcquiredLock(ILockable @lock) { var table = _threadLocal.GetOrCreate(); if (table.ContainsKey(@lock)) { return(null); } var latch = @lock.Acquire(); return(table[@lock] = latch); }
public ExprTimePeriodEvalDeltaConstGivenDtxAdd( ExprTimePeriodImpl.TimePeriodAdder[] adders, int[] added, TimeZoneInfo timeZone, TimeAbacus timeAbacus) { _iLock = LockManager.CreateLock(MethodBase.GetCurrentMethod().DeclaringType); _adders = adders; _added = added; _dateTime = new DateTimeEx(DateTimeOffset.Now, timeZone); _timeAbacus = timeAbacus; _indexMicroseconds = ExprTimePeriodUtil.FindIndexMicroseconds(adders); }
public TimeWinRunnable( int threadNum, EPRuntime epRuntime, ILockable sharedLock, string[] symbols, int numberOfEvents) { _threadNum = threadNum; _epRuntime = epRuntime; _sharedLock = sharedLock; _symbols = symbols; _numberOfEvents = numberOfEvents; }
/// <summary> /// Do not return an item whose timestamp is later than the current /// transaction timestamp. (Otherwise we might compromise repeatable /// read unnecessarily.) Do not return an item which is soft-locked. /// Always go straight to the database instead. /// </summary> /// <remarks> /// Note that since reading an item from that cache does not actually /// go to the database, it is possible to see a kind of phantom read /// due to the underlying row being updated after we have read it /// from the cache. This would not be possible in a lock-based /// implementation of repeatable read isolation. It is also possible /// to overwrite changes made and committed by another transaction /// after the current transaction read the item from the cache. This /// problem would be caught by the update-time version-checking, if /// the data is versioned or timestamped. /// </remarks> public object Get(CacheKey key, long txTimestamp) { lock (_lockObject) { if (log.IsDebugEnabled()) { log.Debug("Cache lookup: {0}", key); } // commented out in H3.1 /*try * { * cache.Lock( key );*/ ILockable lockable = (ILockable)cache.Get(key); bool gettable = lockable != null && lockable.IsGettable(txTimestamp); if (gettable) { if (log.IsDebugEnabled()) { log.Debug("Cache hit: {0}", key); } return(((CachedItem)lockable).Value); } else { if (log.IsDebugEnabled()) { if (lockable == null) { log.Debug("Cache miss: {0}", key); } else { log.Debug("Cached item was locked: {0}", key); } } return(null); } /*} * finally * { * cache.Unlock( key ); * }*/ } }
public void Lock_WhenCalledWithMultipleObjects_ShouldLockInHashOrder(ILockable lock1, ILockable lock2, ILockable lock3) { lock1.Lock.Returns(new object()); lock2.Lock.Returns(new object()); lock3.Lock.Returns(new object()); lock1.Hash.Returns(100); lock2.Hash.Returns(200); lock3.Hash.Returns(300); locker.Lock(new[] { lock3, lock1, lock2 }); enterObjects.Should().Equal(lock1.Lock, lock2.Lock, lock3.Lock); }
/// <summary> /// Ctor. /// </summary> /// <param name="container">The container.</param> /// <param name="typesPerObject">shareable collection that this adapter writes tofor caching bean types per class</param> /// <param name="eventAdapterService">factory for event beans and event types</param> /// <param name="eventTypeIdGenerator">The event type id generator.</param> public BeanEventAdapter( IContainer container, IDictionary <Type, BeanEventType> typesPerObject, EventAdapterService eventAdapterService, EventTypeIdGenerator eventTypeIdGenerator) { _container = container; _typesPerObject = typesPerObject; _typesPerObjectLock = _container.LockManager().CreateLock(GetType()); _typeToLegacyConfigs = new Dictionary <String, ConfigurationEventTypeLegacy>(); _defaultPropertyResolutionStyle = PropertyResolutionStyle.DEFAULT; _eventAdapterService = eventAdapterService; _eventTypeIdGenerator = eventTypeIdGenerator; }
public static int CompareObject(ILockable x, ILockable y) { var hashDiff = x.Hash.CompareTo(y.Hash); if (hashDiff != 0) { return(hashDiff); } var xType = x.GetType(); var yType = y.GetType(); return(String.Compare(xType.AssemblyQualifiedName, yType.AssemblyQualifiedName, StringComparison.InvariantCulture)); }
public ILockable FindLocakbleTarget() { Collider[] cols = Physics.OverlapSphere(transform.position, 20); for (int i = 0; i < cols.Length; i++) { ILockable lockable = cols[i].GetComponent <ILockable>(); if (lockable != null) { return(lockable); } } return(null); }
/// <summary> /// Ctor. /// </summary> /// <param name="runtime">for processing events</param> /// <param name="beanEventType">the event type</param> /// <param name="eventAdapterService">factory for event beans and event types</param> /// <param name="threadingService">for inbound threading</param> /// <param name="lockManager">The lock manager.</param> public EventSenderBean( EPRuntimeEventSender runtime, BeanEventType beanEventType, EventAdapterService eventAdapterService, ThreadingService threadingService, ILockManager lockManager) { _iLock = lockManager.CreateLock(GetType()); _runtime = runtime; _beanEventType = beanEventType; _eventAdapterService = eventAdapterService; _compatibleClasses = new HashSet <Type>(); _threadingService = threadingService; }
protected T Invoke <T>(Authentication authentication, ILockable lockable, Func <T> func) { //using (UsingDataBase.Set(lockable as IServiceProvider, authentication, true)) { if (lockable is IDispatcherObject dispatcherObject) { return(dispatcherObject.Dispatcher.Invoke(func)); } else { return(func()); } } }
public void CheckAccess(ILockable lockable, AccessType accessType) { for (int i = locks.Length - 1; i >= 0; --i) { var tableLock = locks[i]; if (tableLock.Lockable == lockable) { tableLock.CheckAccess(accessType); return; } } throw new Exception("The given object was not found in the lock list for this handle"); }
/// <summary> /// Do not add an item to the cache unless the current transaction /// timestamp is later than the timestamp at which the item was /// invalidated. (Otherwise, a stale item might be re-added if the /// database is operating in repeatable read isolation mode.) /// </summary> /// <returns>Whether the item was actually put into the cache</returns> public async Task <bool> PutAsync(CacheKey key, object value, long txTimestamp, object version, IComparer versionComparator, bool minimalPut, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (txTimestamp == long.MinValue) { // MinValue means cache is disabled return(false); } cancellationToken.ThrowIfCancellationRequested(); using (await(_asyncReaderWriterLock.WriteLockAsync()).ConfigureAwait(false)) { if (log.IsDebugEnabled()) { log.Debug("Caching: {0}", key); } var lockValue = await(_cache.LockAsync(key, cancellationToken)).ConfigureAwait(false); try { ILockable lockable = (ILockable)await(Cache.GetAsync(key, cancellationToken)).ConfigureAwait(false); bool puttable = lockable == null || lockable.IsPuttable(txTimestamp, version, versionComparator); if (puttable) { await(Cache.PutAsync(key, CachedItem.Create(value, Cache.NextTimestamp(), version), cancellationToken)).ConfigureAwait(false); if (log.IsDebugEnabled()) { log.Debug("Cached: {0}", key); } return(true); } else { if (log.IsDebugEnabled()) { log.Debug(lockable.IsLock ? "Item was locked: {0}" : "Item was already cached: {0}", key); } return(false); } } finally { await(_cache.UnlockAsync(key, lockValue, cancellationToken)).ConfigureAwait(false); } } }
public static void Handle(Character chr, ILockable lockable, LockInteractionType type) { var handler = InteractionHandlers.Get((uint)type); if (handler != null) { handler(lockable, chr); } else { log.Error("{0} trying to interact with lockable \"{1}\", but the used InteractionType \"{2}\" is not handled.", chr, lockable, type); } }
public void Do_Generic_ExecutesProtectedBlock( ILockable lck) { bool wasCalled = false; Func <string> block = () => { wasCalled = true; return("hello"); }; locker.Lock(new[] { lck }).Do(block); wasCalled.Should().BeTrue(); }
protected void Invoke(Authentication authentication, ILockable lockable, Action action) { //using (UsingDataBase.Set(lockable as IServiceProvider, authentication, true)) { if (lockable is IDispatcherObject dispatcherObject) { dispatcherObject.Dispatcher.Invoke(action); } else { action(); } } }
/// <summary>Open a GameObject</summary> public static void Open(ILockable lockable, Character chr) { if (!(lockable is GameObject)) { return; } GameObject go = lockable as GameObject; go.Use(chr); if (!(go.Map is Battleground)) { return; } (go.Map as Battleground).OnPlayerClickedOnflag(go, chr); }
/// <summary> /// Loot a container's contents /// </summary> public static void Loot(ILockable lockable, Character user) { if (lockable is Item) { LootMgr.CreateAndSendObjectLoot(lockable, user, LootEntryType.Item, user.Map.IsHeroic); } else if (lockable is GameObject) { ((GameObject)lockable).Handler.Use(user); } else { log.Error("{0} tried to loot invalid object: " + lockable, user); } }
private LockTimeoutException TimeoutException(ILockable lockable, AccessType accessType, int timeout) { ObjectName tableName; if (lockable is IDbObject) { tableName = ((IDbObject)lockable).ObjectInfo.FullName; } else { tableName = new ObjectName(lockable.RefId.ToString()); } return(new LockTimeoutException(tableName, accessType, timeout)); }
public static void Handle(Character chr, ILockable lockable, LockInteractionType type) { LockEntry.InteractionHandler interactionHandler = LockEntry.InteractionHandlers.Get <LockEntry.InteractionHandler>((uint)type); if (interactionHandler != null) { interactionHandler(lockable, chr); } else { LockEntry.log.Error( "{0} trying to interact with lockable \"{1}\", but the used InteractionType \"{2}\" is not handled.", (object)chr, (object)lockable, (object)type); } }
/// <summary>Close an object</summary> public static void Close(ILockable lockable, Character user) { if (!(lockable is GameObject)) { return; } GameObject go = lockable as GameObject; go.State = GameObjectState.Disabled; if (!(go.Map is Battleground)) { return; } (go.Map as Battleground).OnPlayerClickedOnflag(go, user); }
public bool CanInsert(object parent, object child) { var hierarchical = parent.AsAll <IHierarchical>(); if (hierarchical == null) { return(false); } ILockable lockable = parent.As <ILockable>(); if (lockable != null && lockable.IsLocked) { return(false); } DomNode parentNode = parent.As <DomNode>(); IEnumerable <object> items = Util.ConvertData(child, false); bool canInsert = false; foreach (object item in items) { DomNode childNode = item as DomNode; if (parentNode != null && childNode != null) { if ((parentNode.IsDescendantOf(childNode) || parentNode == childNode || parentNode == childNode.Parent)) { return(false); } } IResource res = item as IResource; var gob = m_resourceConverterService.Convert(res); foreach (var h in hierarchical) { if (h.CanAddChild(item) || h.CanAddChild(gob)) { canInsert = true; break; } } } return(canInsert); }
/// <summary> /// Construct a locking strategy based on SQL UPDATE statements. /// </summary> /// <param name="lockable">The metadata for the entity to be locked. </param> /// <param name="lockMode">Indictates the type of lock to be acquired. </param> /// <remarks> /// read-locks are not valid for this strategy. /// </remarks> public UpdateLockingStrategy(ILockable lockable, LockMode lockMode) { this.lockable = lockable; this.lockMode = lockMode; if (lockMode.LessThan(LockMode.Upgrade)) { throw new HibernateException("[" + lockMode + "] not valid for update statement"); } if (!lockable.IsVersioned) { log.Warn("write locks via update not supported for non-versioned entities [" + lockable.EntityName + "]"); sql = null; } else { sql = GenerateLockString(); } }
internal void CheckAccess(ILockable lockable, AccessType accessType, int timeout) { if (accessType == AccessType.ReadWrite) { CheckAccess(lockable, AccessType.Read, timeout); CheckAccess(lockable, AccessType.Write, timeout); return; } for (int i = locks.Length - 1; i >= 0; --i) { var @lock = locks[i]; if (@lock.Lockable.RefId.Equals(lockable.RefId) && @lock.AccessType == accessType) { @lock.CheckAccess(accessType, timeout); return; } } throw new Exception("The given object was not found in the lock list for this handle"); }
public LockHandle Lock(ILockable[] lockables, AccessType accessType, LockingMode mode) { lock (this) { int count = 0; if ((accessType & AccessType.Read) != 0) count += lockables.Length; if ((accessType & AccessType.Write) != 0) count += lockables.Length; var handle = new LockHandle(count); if ((accessType & AccessType.Read) != 0) AddToHandle(handle, lockables, AccessType.Read, mode); if ((accessType & AccessType.Write) != 0) AddToHandle(handle, lockables, AccessType.Write, mode); return handle; } }
public RelockTimer(Mobile from, ILockable o, TimeSpan delay) : base(delay) { Priority = TimerPriority.TwoFiftyMS; m_from = from; o_obj = o; }
private void CheckAccess(ILockable[] lockables, AccessType accessType) { if (lockHandles == null || lockables == null) return; foreach (var handle in lockHandles) { foreach (var lockable in lockables) { if (handle.IsHandled(lockable)) handle.CheckAccess(lockable, accessType); } } }
internal LockingQueue(IDatabase database, ILockable lockable) { Database = database; Lockable = lockable; locks = new List<Lock>(); }
public override void Initialize(ref SpellFailedReason failReason) { if (m_cast.Selected != null) { lockable = m_cast.Selected as GameObject; } else { lockable = m_cast.TargetItem; } if (lockable == null) { failReason = SpellFailedReason.BadTargets; } else { var lck = lockable.Lock; var chr = m_cast.CasterChar; if (lck == null) { log.Warn("Using OpenLock on object without Lock: " + lockable); failReason = SpellFailedReason.Error; return; } if (chr == null) { log.Warn("Using OpenLock without Character: " + chr); failReason = SpellFailedReason.Error; return; } if (!lck.IsUnlocked) { var type = (LockInteractionType)Effect.MiscValue; if (lck.Keys.Length > 0 && m_cast.CasterItem != null) { if (!lck.Keys.Contains(key => key.KeyId == m_cast.CasterItem.Template.ItemId)) { failReason = SpellFailedReason.ItemNotFound; return; } } else if (!lck.Supports(type)) { failReason = SpellFailedReason.BadTargets; return; } if (type != LockInteractionType.None) { foreach (var openingMethod in lck.OpeningMethods) { if (openingMethod.InteractionType == type) { if (openingMethod.RequiredSkill != SkillId.None) { skill = chr.Skills[openingMethod.RequiredSkill]; if (skill == null || skill.ActualValue < openingMethod.RequiredSkillValue) { failReason = SpellFailedReason.MinSkill; } } method = openingMethod; break; } } if (method == null) { // we are using the wrong kind of spell on the target failReason = SpellFailedReason.BadTargets; } } } if (failReason != SpellFailedReason.Ok) { // spell failed if (lockable is GameObject && ((GameObject)lockable).Entry.IsConsumable) { // re-enable GO ((GameObject)lockable).State = GameObjectState.Enabled; } } } }
public GlobalMutexScope(string key) { _concurrentLock = AquireConcurrentLock(key); }
public void Lock(ILockable[] toWrite, ILockable[] toRead, LockingMode mode) { lock (Database) { if (lockHandles == null) lockHandles = new List<LockHandle>(); var handle = Database.DatabaseContext.Locker.Lock(toWrite, toRead, mode); if (handle != null) lockHandles.Add(handle); } }
private void AddToHandle(LockHandle handle, ILockable[] lockables, AccessType accessType, LockingMode mode) { if (lockables == null) return; for (int i = lockables.Length - 1; i >= 0; --i) { var lockable = lockables[i]; var queue = GetQueueFor(lockable); handle.AddLock(queue.NewLock(mode, accessType)); } }
public void Remove(ILockable lockable) { composite.Remove(lockable); }
public bool UseOn( Mobile from, ILockable o ) { if ( o.KeyValue == this.KeyValue ) { if ( o is BaseDoor && !((BaseDoor)o).UseLocks() ) { return false; } else { o.Locked = !o.Locked; if ( o is LockableContainer ) { LockableContainer cont = (LockableContainer)o; if ( cont.LockLevel == -255 ) cont.LockLevel = cont.RequiredSkill - 10; } if ( o is Item ) { Item item = (Item) o; if ( o.Locked ) item.SendLocalizedMessageTo( from, 1048000 ); // You lock it. else item.SendLocalizedMessageTo( from, 1048001 ); // You unlock it. if ( item is LockableContainer ) { LockableContainer cont = (LockableContainer) item; if ( cont.TrapType != TrapType.None && cont.TrapOnLockpick ) { if ( o.Locked ) item.SendLocalizedMessageTo( from, 501673 ); // You re-enable the trap. else item.SendLocalizedMessageTo( from, 501672 ); // You disable the trap temporarily. Lock it again to re-enable it. } } } return true; } } else { return false; } }
private LockingQueue GetQueueFor(ILockable lockable) { LockingQueue queue; if (!queuesMap.TryGetValue(lockable.RefId, out queue)) { queue = new LockingQueue(Database, lockable); queuesMap[lockable.RefId] = queue; } return queue; }
public SelectLockingStrategy(ILockable lockable, LockMode lockMode) { this.lockable = lockable; this.lockMode = lockMode; sql = GenerateLockString(); }
public GlobalMutexScope(string key, LockStyle style, TimeSpan cacheTimeout, TimeSpan retryTimeout) { _concurrentLock = AquireConcurrentLock(key, style, cacheTimeout, retryTimeout); }
public GlobalMutexScope(string key, LockStyle style) { _concurrentLock = AquireConcurrentLock(key, style); }
public void Remove(ILockable lockable) { if(locked) lockable.Unlock(); lockables.Remove(lockable); }
public void Lock(ILockable[] toWrite, ILockable[] toRead, LockingMode mode) { }
public void Add(ILockable lockable) { composite.Add(lockable); }
private LockTimeoutException TimeoutException(ILockable lockable, AccessType accessType, int timeout) { ObjectName tableName; if (lockable is IDbObject) { tableName = ((IDbObject) lockable).ObjectInfo.FullName; } else { tableName = new ObjectName(lockable.RefId.ToString()); } return new LockTimeoutException(tableName, accessType, timeout); }
/// <summary> /// Get a strategy instance which knows how to acquire a database-level lock /// of the specified mode for this dialect. /// </summary> /// <param name="lockable">The persister for the entity to be locked. </param> /// <param name="lockMode">The type of lock to be acquired. </param> /// <returns> The appropriate locking strategy. </returns> public virtual ILockingStrategy GetLockingStrategy(ILockable lockable, LockMode lockMode) { return new SelectLockingStrategy(lockable, lockMode); }
/* Constructor */ public Key(ILockable o) { m_Object = o; }
public static void Lock(this IUserSession session, LockingMode mode) { var lockable = new ILockable[] { session.Transaction }; session.Lock(lockable, lockable, LockingMode.Exclusive); }
/// <summary> /// Is the client's lock commensurate with the item in the cache? /// If it is not, we know that the cache expired the original /// lock. /// </summary> private bool IsUnlockable( ISoftLock clientLock, ILockable myLock ) { //null clientLock is remotely possible but will never happen in practice return myLock != null && myLock.IsLock && clientLock != null && ( ( CacheLock ) clientLock ).Id == ( ( CacheLock ) myLock ).Id; }