private void InitializeHelperObjects() { // DocManager DocManagerData data = new DocManagerData(); data.FormOwner = this; data.UpdateTitle = true; data.FileDialogFilter = "MaBongPal files (*.mbp)|*.mbp|All Files (*.*)|*.*"; data.NewDocName = "Untitled.mbp"; data.RegistryPath = registryPath; docManager = new DocManager(data); docManager.RegisterFileType("mbp", "mbpfile", "MaBongPal File"); docManager.SaveEvent += new SaveEventHandler(docManager_SaveEvent); docManager.LoadEvent += new LoadEventHandler(docManager_LoadEvent); docManager.OpenEvent += new OpenFileEventHandler(docManager_OpenEvent); docManager.DocChangedEvent += new EventHandler(docManager_DocChangedEvent); docManager.ClearEvent += new EventHandler(docManager_ClearEvent); docManager.NewDocument(); // DragDropManager dragDropManager = new DragDropManager(this); dragDropManager.FileDroppedEvent += new FileDroppedEventHandler(this.dragDropManager_FileDroppedEvent); // MruManager mruManager = new MruManager(); mruManager.Initialize(this, menuFileRecentFiles, registryPath); mruManager.MruOpenEvent += new MruFileOpenEventHandler(mruManager_MruOpenEvent); // ODSExporter odsExporter = new ODSExporter(); }
/// <summary> /// Dispose the File Stream. /// </summary> public void Dispose() { _isDisposed = true; if (_fileStream == null) { return; } if (!_unBuffered) { _fileStream.Dispose(); InUse = false; _fileStream = null; return; } MruManager.Remove(Id); lock (_locker) { if (_fileStream == null) { return; } _fileStream.Dispose(); _fileStream = null; InUse = false; } }
/// <summary> /// Remove an entry with a given key. Notifies subscriber, if there is any, /// of the removed item. /// </summary> /// <param name="key"></param> /// <param name="regionName"></param> /// <returns></returns> public override object Remove(string key, string regionName = null) { if (key == null) { throw new ArgumentNullException("key"); } var cacheKey = new CacheKey(key); CacheEntry cacheValue = null; // remove the item, return if not found. lock (_locker) { var mruEntry = MruManager.GetItem(cacheKey); if (mruEntry == null) { return(null); } // get the Store's Current Key containing the TimeStamp! cacheKey = (CacheKey)mruEntry.Key; cacheValue = mruEntry.Value as CacheEntry; MruManager.Remove(cacheKey); } // Notify the subscriber of the removed item. if (CacheEntrySetRemovedCallback != null) { CacheEntrySetRemovedCallback(new[] { new CacheEntryRemovedArguments(this, CacheEntryRemovedReason.Removed, cacheValue.Convert(cacheKey)) }); } return(cacheValue); }
private void MaintainOpenedFileCount() { if (MruManager.Count <= MaxInstanceCount) { return; } while (MruManager.Count > MruManager.MinCapacity) { Mru.Generic.MruItem <int, FileStream> item = MruManager.PeekInTail(); if (item.Value.InUse) { return; } lock (item.Value._locker) { if (item.Value.InUse || item.Value._fileStream == null) { return; } MruManager.Remove(item.Value.Id); //item.Value._streamPosition = item.Value._fileStream.Position; item.Value._fileStream.Flush(); item.Value._fileStream.Close(); item.Value._fileStream = null; } } }
public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null) { if (key == null) { throw new ArgumentNullException("key"); } if (value == null) { throw new ArgumentNullException("value"); } if (policy == null) { policy = DefaultPolicy; } var now = GetCurrentDate(0); var entry = new CacheEntry(policy, now) { Value = value }; var cacheKey = new CacheKey(key) { TimeStamp = now }; lock (_locker) { var e = MruManager.GetItem(cacheKey); if (e == null) { MruManager.Add(cacheKey, entry); return; } entry = e.Value as CacheEntry; entry.Value = value; // if priotiry is not removable, just update the store w/ value if (entry.NonExpiring) { return; } if (!entry.IsExpired(now)) { // slide the expire time... if (entry.SlidingExpiration > 0) { entry.ExpirationTime = GetCurrentDate(entry.SlidingExpiration); } return; } // adjust policy (set to slide every 5 mins) of the expired item to accomodate this update... if (entry.SlidingExpiration == 0) { entry.SlidingExpiration = TimeSpan.TicksPerMinute * 5; } entry.ExpirationTime = GetCurrentDate(entry.SlidingExpiration); } }
private void DisposeCachedItems() { if (AutoDisposeItem) { // Dispose any cached objects that are disposable. MruManager.Dispose(); } }
/// <summary> /// Update the data stored at a given Address. /// </summary> /// <param name="value"></param> public virtual void Update(object value) { //** Update the Current Entry w/ 'value' CurrentItem.Data = value; //** CurrentItem.DataAddress should be the same as DiskBuffer.DataAddress. WriteToDisk(CurrentItem, false); MruManager.Add(CurrentItem.DiskBuffer.DataAddress, CurrentItem); RegisterChange(true); //IsDirty = true; }
/// <summary> /// Remove ObjectToRemove from the Collection if found, else throws an exception /// </summary> public void Remove(object item) { if (!Contains(item)) { return; } Sop.DataBlock currBlock = this.GetCurrentDataBlock(true); if (GetId(currBlock) >= 0) { MruManager.Remove(GetId(currBlock), true); } DataBlockDriver.Remove(this, currBlock); }
/// <summary> /// Add 'Value' to the Collection /// </summary> public long Add(object value) { var o = new LinkedItemOnDisk(this.DataBlockSize) { Data = value }; WriteToDisk(o, false); UpdateCount(UpdateCountType.Increment); //*** update Current, Last & First if (LastItem.DiskBuffer.DataAddress != -1) { o.PreviousItemAddress = LastItem.DiskBuffer.DataAddress; WriteToDisk(o, false); LinkedItemOnDisk biod = CurrentItem; biod.NextItemAddress = o.DiskBuffer.DataAddress; Sop.DataBlock db = DataBlockDriver.ReadBlockFromDisk(this, LastItem.DiskBuffer.DataAddress, true); if (CurrentItem.DiskBuffer.DataAddress != LastItem.DiskBuffer.DataAddress) { biod = (LinkedItemOnDisk)ReadFromBlock(db); biod.NextItemAddress = o.DiskBuffer.DataAddress; } else { PurifyMeta(biod, db); if (db.SizeOccupied > 0) { biod.DiskBuffer = db; } } WriteToDisk(biod, false); } else { FirstItem.DiskBuffer.DataAddress = o.DiskBuffer.DataAddress; } currentEntry = null; CurrentItem = o; CurrentEntryDataAddress = o.DiskBuffer.DataAddress; currentDataBlock = o.DiskBuffer; LastItem.DiskBuffer.DataAddress = o.DiskBuffer.DataAddress; MruManager.Add(CurrentEntryDataAddress, o); //** update the header RegisterChange(true); //IsDirty = true; return(o.DiskBuffer.DataAddress); }
public void Close() { if (_isDisposed || _fileStream == null) { return; } _fileStream.Close(); if (_unBuffered) { InUse = false; MruManager.Remove(Id); _fileStream = null; } }
/// <summary> /// Returns the Items of the MRU Cache. /// </summary> /// <returns></returns> protected override IEnumerator <KeyValuePair <string, object> > GetEnumerator() { lock (_locker) { var e = MruManager.GetEnumerator(); List <KeyValuePair <string, object> > items = new List <KeyValuePair <string, object> >(); do { items.Add(new KeyValuePair <string, object>( ((CacheKey)e.Current.Key).Key, ((CacheEntry)e.Current.Value).Value)); } while (e.MoveNext()); return(items.GetEnumerator()); } }
public override CacheItem GetCacheItem(string key, string regionName = null) { if (key == null) { throw new ArgumentNullException("key"); } MruItem mruEntry = null; var cacheKey = new CacheKey(key); // code block to get item from store and if found, return it if not expired. Func <bool> block = (() => { lock (_locker) { // try to get from the store mruEntry = MruManager.GetItem(cacheKey); if (mruEntry != null) { cacheKey = (CacheKey)mruEntry.Key; if (IsNotExpired(cacheKey, (CacheEntry)mruEntry.Value, false)) { return(true); } } return(false); } }); if (block()) { return(new CacheItem(key, mruEntry.Value)); } #region try to update the Cache entry if it is expired by calling the Update callback. if (CacheEntrySetUpdateCallback == null) { return(null); } CacheEntrySetUpdateCallback(new CacheEntryUpdateArguments[] { new CacheEntryUpdateArguments(this, CacheEntryRemovedReason.Expired, key, null) }); // try to get from the store a 2nd time and see if item got updated & no longer expired... if (block()) { return(new CacheItem(key, mruEntry.Value)); } #endregion return(null); }
private void ReuseCacheFromPool() { // todo: include InstanceId to the cacheId... string cacheId = string.Format("{0}{1}", File.Filename, GetId()); ICollectionCache cache = CachePoolManager.GetCache(cacheId); if (cache == null) { CachePoolManager.SetCache(cacheId, this); } else { MruManager = cache.MruManager; Blocks = cache.Blocks; MruManager.SetDataStores(this, DataBlockDriver); } }
/// <summary> /// Loads the given <paramref name="logFileToLoad"/> into a new logger window. /// </summary> /// <param name="logFileToLoad">The log file to load into a new logger window.</param> /// <param name="verbose">[Optional] <c>True</c> to inform the user about any load error, otherwise <c>false</c>. Default is <c>True</c>.</param> private void LoadFileIntoLogger(string logFileToLoad, bool verbose = true) { if (!string.IsNullOrEmpty(logFileToLoad) && File.Exists(logFileToLoad)) { ReceiverBase[] knownFileReceiver = { new Log4NetFileReceiver(logFileToLoad, true) , new SyslogFileReceiver(logFileToLoad, true) }; foreach (ReceiverBase receiver in knownFileReceiver) { if (receiver.CanHandleLogFile()) { FrmLogDocument newFileDocument = new FrmLogDocument(receiver); // Disable continues logging by default. newFileDocument.Active = false; // Show the new document. newFileDocument.Show(mainDockPanel); // Add the file to the recently used stack. MruManager.AddFile(logFileToLoad); // Rebuild the MRU list to ensure the opened file is displayed in the menu. RebuildMruList(); return; } } if (verbose) { // Inform the user about the error. MessageBox.Show(this, string.Format( Resources.strOpenLogFileError , Path.GetFileName(logFileToLoad)) , Application.ProductName , MessageBoxButtons.OK , MessageBoxIcon.Error); } } }
public VirtualStore(string name, int mruMinCapacity = 4500, int mruMaxCapacity = 6000) { if (mruMinCapacity < 7) { mruMinCapacity = 7; } if (mruMaxCapacity < 10) { mruMaxCapacity = 10; } if (mruMinCapacity >= mruMaxCapacity) { mruMinCapacity = (int)(mruMaxCapacity * .75); } // todo: change to use ConcurrentMruManager ? for concurrency. MruManager = new MruManager(mruMinCapacity, mruMaxCapacity, new CacheKeyComparer()); MruManager.SetDataStores(this, null); _name = name; }
public override bool Contains(string key, string regionName = null) { if (key == null) { throw new ArgumentNullException("key"); } var cacheKey = new CacheKey(key); bool b; lock (_locker) { // try to get from the store var mruEntry = MruManager.GetItem(cacheKey); if (mruEntry == null) { return(false); } cacheKey = (CacheKey)mruEntry.Key; b = IsNotExpired(cacheKey, (CacheEntry)mruEntry.Value, false); if (b || CacheEntrySetUpdateCallback == null) { return(b); } } // try to update the Cache entry if it is expired by calling the Update callback. CacheEntrySetUpdateCallback(new CacheEntryUpdateArguments[] { new CacheEntryUpdateArguments(this, CacheEntryRemovedReason.Expired, key, null) }); lock (_locker) { // try to get from the store a 2nd time and see if item got updated & no longer expired... var mruEntry = MruManager.GetItem(cacheKey); if (mruEntry != null) { cacheKey = (CacheKey)mruEntry.Key; b = IsNotExpired(cacheKey, (CacheEntry)mruEntry.Value, false); } return(b); } }
private void RecentFileClicked(object sender, LinkLabelLinkClickedEventArgs e) { string logFileToLoad = ((Control)sender).Tag as string; if (!File.Exists(logFileToLoad)) { DialogResult removeRslt = MessageBox.Show( Resources.strMruFileCouldNotBeFound , Application.ProductName , MessageBoxButtons.YesNo , MessageBoxIcon.Warning); if (removeRslt == DialogResult.Yes) { MruManager.RemoveFile(logFileToLoad); } return; } mMainForm.LoadFileIntoLogger(logFileToLoad); }
private void OnMruFileClick(object sender, EventArgs e) { string logFileToLoad = ((ToolStripMenuItem)sender).Tag as string; if (!File.Exists(logFileToLoad)) { DialogResult removeRslt = MessageBox.Show( Resources.strMruFileCouldNotBeFound , Application.ProductName , MessageBoxButtons.YesNo , MessageBoxIcon.Warning); if (removeRslt == DialogResult.Yes) { MruManager.RemoveFile(logFileToLoad); RebuildMruList(); } return; } LoadFileIntoLogger(logFileToLoad); }
/// <summary> /// Flush all "modified" data blocks in cache onto Disk. /// NOTE: cache fault event will also cause modified data blocks /// to be saved to disk and Save will only save those "modified ones" /// that didn't get evicted from cache during said event. /// </summary> public virtual void Flush() { bool saveIt = false; bool saveDelayed = DelaySaveBlocks; if (IsOpen && IsDirty) { //RegisterChange(); IsDirty = false; if (FileStream != null) { //** save the collection Item(s) in cache SaveState |= SaveTypes.CollectionSave; if (!DelaySaveBlocks) { DelaySaveBlocks = MruManager.Count < 20; } MruManager.Flush(); SaveState ^= SaveTypes.CollectionSave; //** save the collection's meta data WriteToDisk(this, !IsPartOfCollection); saveIt = true; AddToBlocks(DiskBuffer, Blocks); } } if (deletedBlocks != null) { deletedBlocks.Flush(); } if (!saveIt) { return; } DelaySaveBlocks = saveDelayed; SaveBlocks(false); }
/// <summary> /// Initialize helper objects from the DocToolkit Library. /// /// Called from Form1_Load. Initialized all objects except /// PersistWindowState wich must be initialized in the /// form constructor. /// </summary> private void InitializeHelperObjects() { // DocManager DocManagerData data = new DocManagerData(); data.FormOwner = this; data.UpdateTitle = true; data.FileDialogFilter = "DrawTools files (*.dtl)|*.dtl|All Files (*.*)|*.*"; data.NewDocName = "Untitled.dtl"; data.RegistryPath = registryPath; docManager = new DocManager(data); docManager.RegisterFileType("dtl", "dtlfile", "DrawTools File"); docManager.SaveEvent += new SaveEventHandler(docManager_SaveEvent); docManager.LoadEvent += new LoadEventHandler(docManager_LoadEvent); docManager.OpenEvent += new OpenFileEventHandler(docManager_OpenEvent); docManager.DocChangedEvent += new EventHandler(docManager_DocChangedEvent); docManager.ClearEvent += new EventHandler(docManager_ClearEvent); docManager.NewDocument(); // DragDropManager dragDropManager = new DragDropManager(this); dragDropManager.FileDroppedEvent += new FileDroppedEventHandler(this.dragDropManager_FileDroppedEvent); // MruManager mruManager = new MruManager(); mruManager.Initialize( this, // owner form menuFileRecentFiles, // Recent Files menu item registryPath); // Registry path to keep MRU list mruManager.MruOpenEvent += new MruFileOpenEventHandler(mruManager_MruOpenEvent); }
System.IO.FileStream IFileStream.Open() { MruManager.Add(Id, this); return(SystemAdaptor.Instance.SystemInterface.UnbufferedOpen(_path, _mode, _access, _share, _sequential, _async, _blockSize)); }
/// <summary> /// Initialize MRU list /// </summary> void InitializeMruList() { mruManager = new MruManager(SettingsManager.ApplicationSettings.RecentFilesList, menuFileRecentFiles); mruManager.FileSelected += new EventHandler <MruFileOpenEventArgs>(mruManager_FileSelected); }
//internal override bool RemoveInMemory(long DataAddress, Transaction.ITransactionLogger Transaction) //{ // if (LastItem != null) // LastItem.Clear(); // if (FirstItem != null) // FirstItem.Clear(); // CurrentItem = null; // base.RemoveInMemory(DataAddress, Transaction); // return true; //} private void RemoveAt(long dataAddress, bool willMove) { if (willMove && !MoveTo(dataAddress)) { return; } if (IsDeletedBlocksList && Count == 1) { return; } Sop.DataBlock currBlock = this.GetCurrentDataBlock(true); if (FirstItem.DiskBuffer.DataAddress == dataAddress) { MoveFirst(); if (MoveNext()) { FirstItem.DiskBuffer.DataAddress = CurrentItem.DiskBuffer.DataAddress; CurrentItem.PreviousItemAddress = -1; Sop.DataBlock db = WriteToBlock(CurrentItem, CurrentItem.DiskBuffer); DataBlockDriver.SetDiskBlock(this, db, false); } else { long address = FirstItem.DiskBuffer.DataAddress; FirstItem.DiskBuffer.DataAddress = LastItem.DiskBuffer.DataAddress = -1; CurrentItem = FirstItem; Sop.DataBlock db = WriteToBlock(CurrentItem, CurrentItem.DiskBuffer); db.DataAddress = address; DataBlockDriver.SetDiskBlock(this, db, false); db.DataAddress = -1; } } else if (LastItem.DiskBuffer.DataAddress == dataAddress) { if (MovePrevious() || FirstItem.DiskBuffer.DataAddress == CurrentItem.DiskBuffer.DataAddress) { LastItem.DiskBuffer.DataAddress = CurrentItem.DiskBuffer.DataAddress; CurrentItem.NextItemAddress = -1; Sop.DataBlock db = WriteToBlock(CurrentItem, CurrentItem.DiskBuffer); DataBlockDriver.SetDiskBlock(this, db, false); } else { throw new InvalidOperationException("Can't go previous but First is not the only item."); } } else { LinkedItemOnDisk curr = CurrentItem; LinkedItemOnDisk prev = null, next = null; if (MoveTo(curr.PreviousItemAddress)) { prev = CurrentItem; } if (MoveTo(curr.NextItemAddress)) { next = CurrentItem; } if (prev != null && next != null) { prev.NextItemAddress = curr.NextItemAddress; next.PreviousItemAddress = curr.PreviousItemAddress; Sop.DataBlock db = WriteToBlock(prev, prev.DiskBuffer); DataBlockDriver.SetDiskBlock(this, db, false); db = WriteToBlock(next, next.DiskBuffer); DataBlockDriver.SetDiskBlock(this, db, false); } } if (MruManager.Count > 0) { MruManager.Remove(dataAddress, true); } DataBlockDriver.Remove(this, currBlock); }
private System.IO.FileStream Open() { MruManager.Add(Id, this); return(Win32.UnbufferedOpen(_path, _mode, _access, _share, _sequential, _async, _blockSize)); }
/// <summary> /// Initialize. NOTE: this function doesn't open the file. /// </summary> /// <param name="file"></param> /// <param name="parameters"> </param> protected internal virtual void Initialize(File.IFile file, params KeyValuePair <string, object>[] parameters) { if (file == null) { throw new ArgumentNullException("file"); } if (transaction == null || (transaction is Transaction.Transaction && ((Transaction.Transaction)transaction).Server != file.Server)) { Transaction.ITransactionLogger trans = file.Transaction; if (trans != null) { trans = ((Transaction.TransactionBase)trans).GetLeafChild(); } if (trans == null || trans is Transaction.Transaction) { transaction = trans; } } if (string.IsNullOrEmpty(this.Name)) { var f = new FileInfo(file.Filename); Name = string.Format("{0} Collection {1}", f.Name, ((Sop.OnDisk.File.File)file).GetNewStoreId()); } if (MruMinCapacity == 0) { MruMinCapacity = file.Profile.MruMinCapacity; } if (MruMaxCapacity == 0) { MruMaxCapacity = file.Profile.MruMaxCapacity; } if (File == null) { File = file; } if (DataBlockSize == DataBlockSize.Unknown) { DataBlockSize = file.DataBlockSize; } HeaderData hd = null; if (parameters != null && parameters.Length > 0) { foreach (KeyValuePair <string, object> o in parameters) { switch (o.Key) { case "HasMruSegments": break; case "HeaderData": hd = (HeaderData)o.Value; break; default: if (o.Key == "DataBlockDriver" && o.Value != null) { DataBlockDriver = (IDataBlockDriver)o.Value; } break; } } } if (DataBlockDriver == null) { DataBlockDriver = new DataBlockDriver(this, hd); } else { if (DataBlockDriver.HeaderData == null) { DataBlockDriver.HeaderData = hd ?? new HeaderData(DataBlockSize); } } if (MruManager == null) { int min = MruMinCapacity; int max = MruMaxCapacity; //MruManager = new ConcurrentMruManager(min, max); MruManager = new MruManager(min, max); MruManager.SetDataStores(this, DataBlockDriver); } if (_diskBuffer == null) { _diskBuffer = CreateBlock(); //new Sop.DataBlock(DataBlockSize); } }
private void OnMruClearItems(object sender, EventArgs e) { MruManager.ClearFiles(); RebuildMruList(); }
/// <summary> /// Initialize helper objects from the DocToolkit Library. /// /// Called from Form1_Load. Initialized all objects except /// PersistWindowState wich must be initialized in the /// form constructor. /// </summary> private void InitializeHelperObjects() { // DocManager DocManagerData data = new DocManagerData(); data.FormOwner = this; data.UpdateTitle = true; data.FileDialogFilter = "DrawTools files (*.dtl)|*.dtl|All Files (*.*)|*.*"; data.NewDocName = "Untitled.dtl"; data.RegistryPath = registryPath; docManager = new DocManager(data); docManager.RegisterFileType("dtl", "dtlfile", "DrawTools File"); // Subscribe to DocManager events. docManager.SaveEvent += docManager_SaveEvent; docManager.LoadEvent += docManager_LoadEvent; // Make "inline subscription" using anonymous methods. docManager.OpenEvent += delegate(object sender, OpenFileEventArgs e) { // Update MRU List if (e.Succeeded) { mruManager.Add(e.FileName); } else { mruManager.Remove(e.FileName); } }; docManager.DocChangedEvent += delegate(object o, EventArgs e) { drawArea.Refresh(); drawArea.ClearHistory(); }; docManager.ClearEvent += delegate(object o, EventArgs e) { if (drawArea.GraphicsList != null) { drawArea.GraphicsList.Clear(); drawArea.ClearHistory(); drawArea.Refresh(); } }; docManager.NewDocument(); // DragDropManager dragDropManager = new DragDropManager(this); dragDropManager.FileDroppedEvent += delegate(object sender, FileDroppedEventArgs e) { OpenDocument(e.FileArray.GetValue(0).ToString()); }; // MruManager mruManager = new MruManager(); mruManager.Initialize( this, // owner form recentFilesToolStripMenuItem, // Recent Files menu item fileToolStripMenuItem, // parent registryPath); // Registry path to keep MRU list mruManager.MruOpenEvent += delegate(object sender, MruFileOpenEventArgs e) { OpenDocument(e.FileName); }; }
private static void MaintainOpenedFileCount(bool closeAll = false) { if (MruManager.Count <= MaxInstanceCount) { return; } lock (MruManager) { int ctr = 0; while (closeAll || MruManager.Count > MruManager.MinCapacity) { if (ctr++ >= MruManager.MaxCapacity - 10) { Log.Logger.Instance.Verbose("MaintainOpenedFileCount FileStream trimming loop reached {0}, ending trimming...", ctr); break; } Mru.Generic.MruItem <int, FileStream> item = MruManager.PeekInTail(); //if (item.Value.InUse) return; lock (item.Value._locker) { if (MruManager.Count <= MruManager.MinCapacity) { if (item.Value._fileStream == null) { MruManager.Remove(item.Value.Id); return; } if (item.Value.InUse) { return; } } if (item.Value.InUse) { item.Value.InUse = true; continue; } //item.Value._streamPosition = item.Value._fileStream.Position; if (item.Value._fileStream != null || !item.Value._isDisposed) { item.Value.InUse = true; if (item.Value._fileStream != null || !item.Value._isDisposed) { try { item.Value._fileStream.Flush(); if (item.Value._fileStream != null) { item.Value._fileStream.Close(); } } catch { } } item.Value._fileStream = null; MruManager.Remove(item.Value.Id); item.Value.InUse = false; } else { MruManager.Remove(item.Value.Id); } } } } }