示例#1
0
        /// <summary>
        ///		Create data file accessor instance.
        /// </summary>
        /// <param name="folder">
        ///		Data folder containig the file.
        /// </param>
        /// <param name="file">
        ///		Data file to be accessed; may not exist on disk.
        /// </param>
        /// <returns>
        ///		New <see cref="IDataFileAccessor"/> instance.
        /// </returns>
        public IDataFileAccessor GetDataFileAccessor(IDataFolder folder, IRepositoryFileName file)
        {
            Check.DoRequireArgumentNotNull(folder, "folder");
            Check.DoRequireArgumentNotNull(file, "file");
            RepositoryFolder.CheckNotDetached(folder.RepoFolder);

            return(new RepositoryFileAccessor(folder, file));
        }
示例#2
0
        /// <summary>
        ///		Create new instance.
        /// </summary>
        /// <param name="containingFolder">
        ///		Leaf data folder object reference, mandatory.
        /// </param>
        /// <param name="fileName">
        ///		Object representing data file name, optional.
        /// </param>
        public RepositoryFile(IDataFolder containingFolder, IRepositoryFileName fileName)
        {
            Check.DoRequireArgumentNotNull(containingFolder, "containingFolder");
            RepositoryFolder.CheckNotDetached(containingFolder.RepoFolder);

            ContainingFolder = containingFolder;
            Name             = fileName;
        }
 public RaceJsonRepository(IDataFolder dataFolder)
 {
     this.dataFolder = dataFolder;
     this.mutex      = new ReaderWriterLockSlim();
     this.serializer = JsonSerializer.CreateDefault();
     this.serializer.Converters.Add(new SexJsonConverter());
     this.raceData = null;
 }
 /// <summary>
 ///		Discarding changes if dirty. Call <see cref="Flush"/> to save changes.
 /// </summary>
 public void Close()
 {
     FirstItemTimestamp = DateTime.MaxValue;
     LastItemTimestamp  = DateTime.MinValue;
     _existinglFilePath = null;
     _dataItems         = null;
     _dataFolder        = null;
     _repoFile          = null;
 }
 /// <summary>
 ///		Create accessor for a file and retrieve compressor from repository's
 ///		object factory by the file extension
 /// </summary>
 /// <param name="folder">
 ///		Containing repo folder
 /// </param>
 /// <param name="repoFile">
 ///		Target data file, optional.
 /// </param>
 /// <param name="dataFolder">
 ///		Leaf data folder containing <paramref name="repoFile"/>
 /// </param>
 /// <param name="equalTimestampedItemsComparer">
 ///		Comparer for data items with equal timestamps, optional.
 /// </param>
 internal RepositoryFileAccessor(
     IFolder folder
     , IRepositoryFileName repoFile
     , IDataFolder dataFolder
     , IComparer <IDataItem> equalTimestampedItemsComparer)
     : this(dataFolder, repoFile
            , folder.Repository.ObjectFactory.GetCompressor(repoFile.CompressorCode)
            , equalTimestampedItemsComparer)
 {
 }
示例#6
0
 public AthletesJsonRepository(IDataFolder dataFolder)
 {
     this.dataFolder         = dataFolder;
     this.mutex              = new ReaderWriterLockSlim();
     this.allAthletesIds     = null;
     this.individualAthletes = new Dictionary <string, Athlete>();
     this.serializer         = JsonSerializer.CreateDefault();
     this.serializer.Converters.Add(new SexJsonConverter());
     this.serializer.Converters.Add(new CardResultJsonConverter());
 }
示例#7
0
 public JudgesJsonRepository(IDataFolder dataFolder)
 {
     this.dataFolder           = dataFolder;
     this.mutex                = new ReaderWriterLockSlim();
     this.isLoaded             = false;
     this.judgesById           = new Dictionary <string, Judge>();
     this.devicesById          = new Dictionary <string, JudgeDevice>();
     this.devicesByConnectCode = new Dictionary <string, JudgeDevice>();
     this.authenticationMap    = new Dictionary <string, string>();
     this.serializer           = JsonSerializer.CreateDefault();
 }
        /// <summary>
        ///		Find a place for data item with the specified timestamp
        /// </summary>
        /// <exception cref="System.IO.FileNotFoundException">
        ///		File found in the data file container was not found on disk, by virtue of <see cref="RepositoryFileAccessor.ReadFromFile"/>.
        ///		Possible concurrent update; better shut down.
        /// </exception>
        private void Seek(DateTime seekTimestamp)
        {
            if (null == _currentFolder ||
                !IsCovering(_currentFolder, seekTimestamp))
            {
                // need to change current leaf data folder
                _currentFolder = _targetFolder.RootDataFolder.GetLeafFolder(seekTimestamp, true);
            }

            IRepositoryFileName targetFile;
            IRepositoryFileName predecessor;
            IRepositoryFileName successor;

            _currentFolder.DataFileBrowser.GetDataFiles(seekTimestamp, out predecessor, out targetFile, out successor);

            bool openingExistingFile = targetFile != null;

            if (!openingExistingFile)
            {
                // new file needed
                targetFile = _targetFolder.Repository.ObjectFactory.CreateNewFile(_targetFolder);
            }

            _currentAccessor = GetAccessor(targetFile);

            if (openingExistingFile)
            {
                // will throw exception if file was not found or failed to read
                _currentAccessor.ReadFromFile();
            }

            _currentAccessor.Encryptor = this.Encryptor;

            // set timestamp limits
            if (null != predecessor)
            {
                _currentAccessor.MinTimestampToAccept = predecessor.LastItemTimestamp.AddTicks(1);
            }
            else
            {
                _currentAccessor.MinTimestampToAccept = _currentFolder.Start;
            }

            if (null != successor)
            {
                _currentAccessor.MaxTimestampToAccept = successor.FirstItemTimestamp.AddTicks(-1);
            }
            else
            {
                _currentAccessor.MaxTimestampToAccept = _currentFolder.End.AddTicks(-1);
            }

            Check.Ensure(null != _currentAccessor);
        }
示例#9
0
 /// <summary>
 ///		Get child data folder which next to the specified child folder.
 /// </summary>
 /// <param name="childFolder">
 ///		The child folder which neighbour to find
 /// </param>
 /// <param name="backwards">
 ///		Whether to find next folder older than the <paramref name="childFolder"/> (<see langword="true"/>)
 ///		or newer (<see langword="false"/>). Older means smaller timestamp.
 /// </param>
 /// <returns>
 ///		Existing data folder which is a child of this data folder or <see langword="null"/> if the sought data folder
 ///		does not exist.
 /// </returns>
 public IDataFolder GetNextChild(IDataFolder childFolder, bool backwards)
 {
     LoadSubFolders(false);
     if (backwards)
     {
         return(_childDataFolders.GetPredecessor(childFolder.Start));
     }
     else
     {
         // GetSuccessor accepts item key, adjusting End as it's exclusive
         return(_childDataFolders.GetSuccessor(childFolder.End.AddTicks(-1)));
     }
 }
示例#10
0
        /// <summary>
        ///		Read the list of immediately contained subfolders
        ///		from disk.
        ///		For leaf folders does nothing.
        /// </summary>
        /// <param name="reloadIfLoaded"></param>
        public void LoadSubFolders(bool reloadIfLoaded)
        {
            Invariant();

            if (!this.IsLeafFolder)
            {
                if (!this.SubfoldersLoaded || reloadIfLoaded)
                {
                    _log.DebugFormat("LoadSubFolders: Scanning <{0}> for subfolders", RelativePath);

                    // in the year-month scheme this will be year or root data folder
                    // i.e. _repoFolder.DataFoldersExplorer will be parent at most
                    // note that current implementation requires this to be a child
                    // how will it be affected with the addition of another level?
                    // it will not be valid; need to make it more explicit; there's coupling between DataFolder and folder traits
                    // or, if I add more levels I will need to lift the limitation in DataFoldersExplorer implementation
                    List <IRepoFileContainerDescriptor> subFolders = _repoFolder.DataFoldersExplorer.Enumerate(_folderDescriptor, this.Level - 1);

                    IIndexedRangeCollection <DateTime, IDataFolder> oldList = _childDataFolders;
                    _childDataFolders = new IndexedRangeTreeDictionary <DateTime, IDataFolder>(f => f.Start, f => f.End);

                    foreach (IRepoFileContainerDescriptor descr in subFolders)
                    {
                        _log.DebugFormat("Found subfolder {0}", descr.ToString());
                        IDataFolder newSubFolder = null;
                        if (null != oldList)
                        {
                            newSubFolder = oldList.GetExact(descr.Start);
                        }
                        if (null == newSubFolder)
                        {
                            newSubFolder = new DataFolder(this, descr);
                            _log.Debug("The found subfolder was not in the list");
                        }
                        else
                        {
                            _log.Debug("The subfolder was already in the list");
                        }
                        _childDataFolders.Add(newSubFolder);
                    }
                }
            }
            else
            {
                _log.Debug("LoadSubFolders called for leaf folder");
            }
        }
示例#11
0
        /// <summary>
        ///		Get first (chronologically) descendant at the specified level
        /// </summary>
        /// <param name="level">
        ///		Level at which to find descendant. Must point to a descendant (i.e. be less than <code>this.Level</code> and greater or
        ///		equal to zero (which is leaf level).
        /// </param>
        /// <param name="backwards">
        ///		Whether to find oldest (<see langword="false"/>) or newest (<see langword="true"/>) descendant.
        /// </param>
        /// <returns>
        ///		First descendant at <paramref name="level"/> or <see langword="null"/> if none exists.
        /// </returns>
        public IDataFolder GetFirstDescendant(int level, bool backwards)
        {
            RequireDescendant(level);

            IDataFolder descendant = GetFirstChildFolder(backwards);

            if (descendant != null && level < (this.Level - 1))
            {
                descendant = descendant.GetFirstDescendant(level, backwards);
            }
            else if (level == (this.Level - 1))
            {
                // reached target level
                return(descendant);
            }
            return(null);
        }
示例#12
0
        /// <summary>
        ///		Get first (chronologically) descendant at the specified level
        /// </summary>
        /// <param name="dataTimestamp">
        ///		The start of the time period (inclusive) for which to find covering data folder
        /// </param>
        /// <param name="level">
        ///		Level at which to find descendant. Must point to a descendant (i.e. be less than <code>this.Level</code> and greater or
        ///		equal to zero (which is leaf level).
        /// </param>
        /// <param name="backwards">
        ///		The direction in which the time period goes from <paramref name="dataTimestamp"/>
        /// </param>
        /// <returns>
        ///		First descendant at <paramref name="level"/> or <see langword="null"/> if none exists.
        /// </returns>
        /// <remarks>
        ///		For example GetFirstDescendant(DateTime.Now, 1, true) will find first existing descendant at level 1
        ///		which covers time starting from now and going to the past.
        /// </remarks>
        public IDataFolder GetFirstDescendant(DateTime dataTimestamp, int level, bool backwards)
        {
            RequireDescendant(level);
            Check.RequireLambda(dataTimestamp >= this.Start && dataTimestamp <= this.End
                                , () => new ArgumentException("The timestamp is outside of the range of the folder", "dataTimestamp"));

            if (IsChild(level))
            {
                return(GetFirstChildFolder(dataTimestamp, backwards));
            }

            IDataFolder retval = null;

            var enumerator = GetSubfoldersSequence(dataTimestamp, backwards).GetEnumerator();

            if (enumerator.MoveNext())
            {
                if (IsCovering(enumerator.Current, dataTimestamp))
                {
                    // enumerator.Current is the "owner"
                    retval = enumerator.Current.GetFirstDescendant(dataTimestamp, level, backwards);
                }
                else
                {
                    // there's no owner, will look for first descendant
                    enumerator.Reset();
                }
            }

            if (retval == null)
            {
                // enumerator will now point past any owner (covering) child folder; so no need to use (filter by) the target timestamp
                // just find first descendant in those folders; need to enumerate because an existing child folder may not have any
                // descendants at the target level
                while (enumerator.MoveNext())
                {
                    retval = enumerator.Current.GetFirstDescendant(level, true);
                    if (null != retval)
                    {
                        break;
                    }
                }
            }

            return(retval);
        }
示例#13
0
        /// <summary>
        ///		Find existing leaf data folder and [optionally] create if it is
        ///		missing. Primarily intended for use by writers.
        /// </summary>
        /// <param name="itemTimestamp">
        ///		The timestamp of an item for which to find the existing
        ///		or create new leaf folder
        /// </param>
        /// <returns>
        ///		Existing leaf folder
        ///		null if the folder is missing and <paramref name="createIfMissing"/>
        ///		is <see langword="false"/>
        /// </returns>
        public IDataFolder GetLeafFolder(DateTime itemTimestamp, bool createIfMissing)
        {
            IDataFolder retval = null;

            if (this.IsLeafFolder)
            {
                if (this.Start <= itemTimestamp && this.End > itemTimestamp)
                {
                    retval = this;
                }
            }
            else             // if (this.IsLeafFolder)
            {
                LoadSubFolders(false);
                retval = _childDataFolders.GetOwner(itemTimestamp);
                if (retval == null && createIfMissing)
                {
                    // creating target subfolder; this will be a child folder of this data folder
                    IRepoFileContainerDescriptor descr = _repoFolder.DataFoldersExplorer.GetTargetFolder(
                        itemTimestamp, this.Level - 1);

                    retval = new DataFolder(this, descr);

                    retval.EnsureDirectoryExists();

                    _childDataFolders.Add(retval);
                }
                if (retval != null)
                {
                    if (retval.Level > 0)
                    {
                        // not a leaf folder yet - drilling down all the way
                        retval = retval.GetLeafFolder(itemTimestamp, createIfMissing);
                    }
                }
            }

            Check.Ensure(null != retval || !createIfMissing);
            Check.Ensure(null == retval || retval.IsLeafFolder);
            Check.Ensure(null == retval || (retval.Start <= itemTimestamp && retval.End > itemTimestamp));

            return(retval);
        }
示例#14
0
        /// <summary>
        ///		Get successor or predecessor of this folder at the same level of the folders hierarchy
        /// </summary>
        /// <param name="backwards">
        ///		<see langword="true"/> for predecessor
        ///		<see langword="false"/> for successor
        /// </param>
        /// <returns>
        ///		<see langword="null"/> if none exist
        /// </returns>
        public IDataFolder GetNextSiblingInTree(bool backwards)
        {
            Check.RequireLambda(!IsVirtualRoot, () => new InvalidOperationException(StorageResources.VirtualRootInvalidOperation));

            IDataFolder retval = ParentDataFolder.GetNextChild(this, backwards);

            if (null == retval)
            {
                if (!ParentDataFolder.IsVirtualRoot)
                {
                    for (
                        IDataFolder nst = ParentDataFolder.GetNextSiblingInTree(backwards);
                        nst != null && retval == null;
                        nst = nst.GetNextSiblingInTree(backwards))
                    {
                        retval = nst.GetFirstChildFolder(backwards);
                    }
                }
            }
            return(retval);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="dataFolder">
        ///		Leaf data folder in which the data files will be accessed.
        /// </param>
        /// <param name="repoFile">
        ///		Target repo file, optional. New instance will be created using object factory if null is supplied.
        /// </param>
        /// <param name="coder">
        ///		Compressor instance
        /// </param>
        /// <param name="equalTimestampedItemsComparer">
        ///		Comparer to use when sorting data items for items with equal timestamps.
        ///		When timestamps are not equal the comparer has no effect.
        /// </param>
        internal RepositoryFileAccessor(
            IDataFolder dataFolder
            , IRepositoryFileName repoFile
            , ICoder coder
            , IComparer <IDataItem> equalTimestampedItemsComparer)
        {
            Check.DoRequireArgumentNotNull(dataFolder, "dataFolder");
            Check.DoRequireArgumentNotNull(repoFile, "repoFile");
            Check.DoRequireArgumentNotNull(coder, "coder");
            RepositoryFolder.CheckNotDetached(dataFolder.RepoFolder);

            _folder     = dataFolder.RepoFolder;
            _repoFile   = repoFile;
            _dataFolder = dataFolder;

            if (_repoFile == null)
            {
                _repoFile = _folder.Repository.ObjectFactory.CreateNewFile(_folder);
            }
            this.Coder = coder;

            if (repoFile.Encrypted)
            {
                this.Encryptor = _folder.Repository.ObjectFactory.GetEncryptor(repoFile.EncryptorCode);
            }

            if (_folder.Repository.ObjectFactory.FileSystemProvider.FileProvider.Exists(this.FilePath))
            {
                _existinglFilePath = this.FilePath;
            }
            else
            {
                _dataItems = new List <IDataItem>();
            }
            _isSorted = true;
            this.EqualTimestampItemsComparer = equalTimestampedItemsComparer;

            FirstItemTimestamp = DateTime.MaxValue;
            LastItemTimestamp  = DateTime.MinValue;
        }
示例#16
0
        /// <summary>
        ///		Cut descendant folders at the specified level.
        /// </summary>
        /// <param name="timestamp">
        ///		Cutting data timesatamp
        /// </param>
        /// <param name="level">
        ///		Level at which to cut. Must point to a descendant (i.e. be less than <see cref="Level"/> and greater or equal to zero
        ///		(which is leaf level).
        /// </param>
        /// <param name="predecessor">
        ///		Output, the existing predecessor at <paramref name="level"/> of a folder, covering <paramref name="timestamp"/>;
        ///		<see langword="null"/> if none exists.
        /// </param>
        /// <param name="owner">
        ///		Output, the data folder at <paramref name="level"/>, covering <paramref name="timestamp"/>.
        ///		<see langword="null"/> if none exists.
        /// </param>
        /// <param name="successor">
        ///		Output, the existing successor at <paramref name="level"/> of a folder, covering <paramref name="timestamp"/>;
        ///		<see langword="null"/> if none exists.
        /// </param>
        public void CutDescendantFolders(DateTime timestamp, int level, out IDataFolder predecessor, out IDataFolder owner, out IDataFolder successor)
        {
            Check.RequireLambda(level >= 0 && level < this.Level, () => new InvalidOperationException(StorageResources.LevelOfDescendantRequired));

            LoadSubFolders(false);

            predecessor = owner = successor = null;

            IDataFolder childPredecessor;
            IDataFolder childOwner;
            IDataFolder childSuccessor;

            _childDataFolders.GetItems(timestamp, out childPredecessor, out childOwner, out childSuccessor);

            if (level < (this.Level - 1))
            {
                // need to dig deeper
                if (childOwner != null)
                {
                    childOwner.CutDescendantFolders(timestamp, level, out predecessor, out owner, out successor);
                }

                // even if childOwner is found it may not be the root of the subtree containing the predecessor at the specified level
                // because there may not be existing descendants at that level;
                if (predecessor == null && childPredecessor != null)
                {
                    predecessor = GetFirstDescendant(childPredecessor.End.AddTicks(-1), level, true);
                }
                if (successor == null && childSuccessor != null)
                {
                    successor = GetFirstDescendant(childSuccessor.Start, level, false);
                }
            }
            else
            {
                predecessor = childPredecessor;
                owner       = childOwner;
                successor   = childSuccessor;
            }
        }
示例#17
0
        /// <summary>
        ///		Get next data file in the same repo folder.
        /// </summary>
        /// <param name="backwards">
        ///		The direction in which to look for data file relative to this file: to the past or to the future
        /// </param>
        /// <returns>
        ///		Next data file or <see langword="null"/> if none exists.
        /// </returns>
        public IRepositoryFile GetNext(bool backwards)
        {
            IRepositoryFile retval = null;

            IRepositoryFileName fileInSameFolder = ContainingFolder.GetNextDataFile(this.Name, backwards);

            if (null != fileInSameFolder)
            {
                retval = new RepositoryFile(containingFolder: ContainingFolder, fileName: fileInSameFolder);
            }
            else
            {
                // scanning sibling leaf folders until first data file is found
                for (
                    IDataFolder nextFolder = ContainingFolder.GetNextSiblingInTree(backwards);
                    nextFolder != null && retval == null;
                    nextFolder = nextFolder.GetNextSiblingInTree(backwards))
                {
                    retval = nextFolder.FindFirstDataFile(backwards);
                }
            }

            return(retval);
        }
 private static bool IsCovering(IDataFolder dataFolder, DateTime itemTimestamp)
 {
     return(dataFolder.Start <= itemTimestamp && dataFolder.End > itemTimestamp);
 }
 /// <summary>
 ///		Create new instance.
 /// </summary>
 /// <param name="folder">
 ///		Data folder where file will be stored.
 /// </param>
 /// <param name="file">
 ///		File name instance, optional.
 /// </param>
 /// <remarks>
 ///		If <paramref name="file"/> is not supplied new instance will be created using the object factory (<see cref="IRepository.ObjectFactory"/>).
 ///		Coder and encryptor will be set from the object factory as well. They may be overridden afterwards.
 /// </remarks>
 public RepositoryFileAccessor(IDataFolder folder, IRepositoryFileName file)
     : this(folder : folder.RepoFolder, repoFile : file, dataFolder : folder, equalTimestampedItemsComparer : null)
 {
 }
示例#20
0
 /// <summary>
 ///		Real existing data folder
 /// </summary>
 /// <param name="parentDataFolder"></param>
 /// <param name="folderDescriptor"></param>
 public DataFolder(DataFolder parentDataFolder, IRepoFileContainerDescriptor folderDescriptor)
 {
     _parentDataFolder = parentDataFolder;
     _folderDescriptor = folderDescriptor;
     _repoFolder       = parentDataFolder.RepoFolder;
 }
示例#21
0
 public StartingListJsonRepository(IDataFolder dataFolder)
 {
     this.dataFolder = dataFolder;
     this.mutex      = new ReaderWriterLockSlim();
     this.serializer = JsonSerializer.CreateDefault();
 }
示例#22
0
        public void MyClassInitialize()
        {
            lock (GetType())
            {
                if (_emptyDataFolder == null)
                {
                    const int itemsCount = 100000;
                    _daysPerFile = ((double)_dataItemsPerFile) * _itemsIntervalMinutes / 60.0 / 24.0;
                    // 200 * 20 minutes = 8000 minutes per file (5.55556 days)

                    DateTime firstTime = DateTime.Now.AddDays(-10);
                    _firstDataItemTime = firstTime;
                    //_expectedFileCount = (int)Math.Ceiling((double)itemsCount / (double)_dataItemsPerFile);

                    IFolder targetFolder     = (IFolder)FixtureRootRepoFolder;
                    string  targetFolderPath = targetFolder.FullPath;

                    targetFolder.Properties.DesiredItemsPerFile = _dataItemsPerFile;
                    using (IRepositoryWriter writer = targetFolder.GetWriter())
                    {
                        DateTime lastTime = DateTime.MinValue;
                        int      n;
                        for (n = 0; n < itemsCount; ++n)
                        {
                            Mock.TestDataItem item = Mock.TestDataItem.GetTestItem(n);
                            lastTime      = firstTime.AddMinutes(n * _itemsIntervalMinutes);
                            item.DateTime = lastTime;
                            writer.Write(item);
                        }

                        _lastDataItemTime = lastTime;

                        writer.Flush();
                        writer.Close();
                    }

                    for (
                        var dataFile = targetFolder.RootDataFolder.FindFirstDataFile(false);
                        dataFile != null;
                        dataFile = dataFile.GetNext(false), ++_expectedFileCount
                        )
                    {
                    }

                    Console.WriteLine("Expected file count enumerated via RepositoryFile: {0}", _expectedFileCount);

                    // data folder boundaries may split data files thus extra ones
                    Assert.GreaterOrEqual(_expectedFileCount, (int)Math.Ceiling((double)itemsCount / (double)_dataItemsPerFile), "Data file count unexpected");

                    // creating empty folder
                    IRepositoryFile file = targetFolder.RootDataFolder.Seek(firstTime.AddMinutes(itemsCount * _itemsIntervalMinutes / 3), false);
                    _emptyDataFolder = file.ContainingFolder;

                    for (
                        file = _emptyDataFolder.FindFirstDataFile(false);
                        file != null && file.ContainingFolder == _emptyDataFolder;
                        file = file.GetNext(false))
                    {
                        file.Delete();
                        --_expectedFileCount;
                    }

                    Assert.AreEqual(0, _emptyDataFolder.DataFileBrowser.FileCount);

                    Console.WriteLine("Expected file count after removing file by file: {0}", _expectedFileCount);

                    //
                    IDataFolder dfolderToDelete = _emptyDataFolder.ParentDataFolder.GetNextSiblingInTree(false).GetNextSiblingInTree(false);

                    Assert.AreEqual(1, dfolderToDelete.Level);

                    _deletedDataFolder = new RepoFileContainerDescriptor()
                    {
                        Start        = dfolderToDelete.Start,
                        End          = dfolderToDelete.End,
                        Level        = dfolderToDelete.Level,
                        RelativePath = dfolderToDelete.RelativePath
                    };

                    _expectedFileCount -= dfolderToDelete.GetSubfolders(DateTime.MinValue, false).Sum((f) => f.DataFileBrowser.FileCount);

                    Console.WriteLine("Expected file count after removing data folder {0}: {1}", dfolderToDelete.PathInRepository, _expectedFileCount);

                    Console.WriteLine("Removing folder {0}", dfolderToDelete.PathInRepository);

                    dfolderToDelete.Delete(false);

                    Assert.IsFalse(dfolderToDelete.Exists);
                }
            }             //lock
        }
示例#23
0
 public RepositorySetJsonProvider(IDataFolder rootFolder)
 {
     this.rootFolder = rootFolder;
 }
示例#24
0
 public SeekFileResult(DateTime seekTime, IDataFolder foundFolder, IRepositoryFileName foundFile)
 {
     this.SeekDateTime   = seekTime;
     this.RepositoryFile = new RepositoryFile(containingFolder: foundFolder, fileName: foundFile);
 }
示例#25
0
 private bool IsCovering(IDataFolder folder, DateTime timestamp)
 {
     return(timestamp >= folder.Start && timestamp < folder.End);
 }