private bool CanContainItemsFromRange(
IRepoFileContainerDescriptor folder,
DateTime rangeStart,
DateTime rangeEnd)
{
return(folder.Start < rangeEnd && folder.End > rangeStart);
}
private List <IRepoFileContainerDescriptor> EnumerateMonths(
IRepoFileContainerDescriptor yearDir)
{
Check.DoAssertLambda(yearDir.Level == FolderLevelYear, () => new ArgumentException("Year level expected in yearDir"));
List <IRepoFileContainerDescriptor> retval = new List <IRepoFileContainerDescriptor>();
string root = Path.Combine(this.RootPath, yearDir.RelativePath);
if (_directoryProvider.Exists(root))
{
IEnumerable <string> monthDirs = _directoryProvider.EnumerateDirectories(
root
, _dirLevelTraits[FolderLevelMonth].DirNameMask);
foreach (string monthDir in monthDirs)
{
int month = 0;
if (_dirLevelTraits[FolderLevelMonth].IsValidDir(_directoryProvider.GetLastPathComponent(monthDir), ref month))
{
IRepoFileContainerDescriptor descrMonth =
_dirLevelTraits[FolderLevelMonth].GetFolderDescriptorByRange(
yearDir.Start.AddMonths(month - 1));
retval.Add(descrMonth);
}
} // foreach (string monthDir in monthDirs)
} // if (Directory.Exists(this.RootPath))
return(retval);
}
internal RepoFileContainerBrowser(
IFolder folder
, IRepoFileContainerDescriptor dataFileContainer)
{
_folder = folder;
_container = dataFileContainer;
}
// implementation
/// <summary>
/// Enumerate child data folders in a parent data folder
/// </summary>
/// <param name="parentFolder">
/// A folder in a tree whose children to enumerate.
/// </param>
/// <param name="level">
/// The level number of folders being enumerated, according to the current depth (not an index in <see cref="_levelTraits"/>)
/// </param>
/// <returns></returns>
private List <IRepoFileContainerDescriptor> EnumerateChildren(IRepoFileContainerDescriptor parentFolder, int level)
{
Check.Require(level >= Constants.DataFolderLevelLeaf && level < LevelCount);
ICalendarHistoricalFolderTraits traits = GetLevelTraits(level);
string parentAbsolutePath = GetAbsolutePath(parentFolder);
IEnumerable <string> allDirPaths = DirectoryProvider.EnumerateDirectories(parentAbsolutePath, traits.NameMask);
List <IRepoFileContainerDescriptor> retval = new List <IRepoFileContainerDescriptor>();
foreach (string name in allDirPaths.Select((p) => DirectoryProvider.GetLastPathComponent(p)))
{
CalendarHistoricalFolderInternalDescriptor internalDesc = traits.GetDescriptor(parentFolder, name);
if (null != internalDesc)
{
IRepoFileContainerDescriptor descr = GetDescriptor(parentFolder, internalDesc);
retval.Add(descr);
}
else
{
_log.WarnFormat("Data folder name {0}/{1} is malformed, ignoring", parentFolder == null ? "" : parentFolder.RelativePath, name);
}
}
return(retval);
}
/// <summary>
/// Get descriptor of an [existing] folder by its name and parent folder.
/// </summary>
/// <param name="parent">
/// Descriptor of a parent folder
/// </param>
/// <param name="folderName">
/// The folder name
/// </param>
/// <returns>
/// <see langword="null"/> if the folder is not a valid historical data folder.
/// <see cref="CalendarHistoricalFolderInternalDescriptor"/> instance otherwise
/// </returns>
public CalendarHistoricalFolderInternalDescriptor GetDescriptor(IRepoFileContainerDescriptor parent, string folderName)
{
Check.RequireArgumentNotNull(parent, "parent");
Check.Require(parent.Start == new DateTime(parent.Start.Year, parent.Start.Month, 1) &&
parent.End.AddMonths(-1) == parent.Start, "Parent of day must be month");
return(GetDescriptor(parent.Start.Year, parent.Start.Month, folderName));
}
/// <summary>
/// Get browser which provides access to data files in a leaf data folder.
/// </summary>
/// <param name="folder">
/// The repository folder for which the browser is required.
/// </param>
/// <param name="fileContainer">
/// Descriptor of leaf data folder.
/// </param>
/// <returns>
/// New browser instance.
/// </returns>
public virtual IRepoFileContainerBrowser GetDataFileBrowser(IFolder folder, IRepoFileContainerDescriptor fileContainer)
{
CheckHelper.CheckRepositoryNotDisposed(Repository);
Check.DoRequireArgumentNotNull(folder, "folder");
Check.DoRequireArgumentNotNull(fileContainer, "fileContainer");
return(new RepoFileContainerBrowser(folder, fileContainer));
}
protected virtual IRepoFileContainerDescriptor GetFolderDescriptor(IRepoFileContainerDescriptor parent, string folderName)
{
int monthNumber = 0;
if (IsValidDir(folderName, ref monthNumber))
{
return(GetFolderDescriptorByRange(parent.Start.AddMonths(monthNumber - 1)));
}
return(null);
}
private static string GetRelativePath(IRepoFileContainerDescriptor parentFolder, string folderName)
{
if (parentFolder == null)
{
return(folderName);
}
else
{
return(Path.Combine(parentFolder.RelativePath, folderName));
}
}
protected override IRepoFileContainerDescriptor GetFolderDescriptor(IRepoFileContainerDescriptor parent, string folderName)
{
Check.Require(null == parent);
int monthNumber = 0;
if (IsValidDir(folderName, ref monthNumber))
{
return(GetFolderDescriptorByRange(parent.Start.AddMonths(monthNumber - 1)));
}
return(null);
}
/// <summary>
/// Enumerate child data folders in the [sub]tree with root at <see cref="RootPath"/>.
/// </summary>
/// <param name="root">
/// Descriptor of the data folder whose children to enumerate
/// </param>
/// <param name="level">
/// Level at which to find data folders; must be the child of the <paramref name="root"/>, i.e. equal to <code>root.Level - 1</code>.
/// </param>
/// <returns>
/// List of children of <paramref name="root"/>.
/// </returns>
/// <exception cref="ArgumentException">
/// <paramref name="level"/> does not represent <paramref name="root"/>'s children.
/// </exception>
public List <IRepoFileContainerDescriptor> Enumerate(IRepoFileContainerDescriptor root, int level)
{
if (root == null)
{
return(Enumerate(level));
}
Check.DoCheckArgument(level >= Constants.DataFolderLevelLeaf, "Leaf level folders do not have child folders");
Check.DoCheckArgument(level == root.Level - 1, "This implementation enumerates children only");
return(EnumerateChildren(root, root.Level - 1));
}
/// <summary>
/// Enumerate descendant data folders in the [sub]tree with root at <paramref name="root"/>
/// </summary>
/// <param name="root">
/// One of the descendants of <see cref="RootPath"/> among the descendants of which
/// to search; specify <see langword="null"/> to search in <see cref="RootPath"/>
/// </param>
/// <param name="level">
/// Level at which to find data folders
/// 0 - leaf level
/// 1 - months
/// 2 - years
/// </param>
/// <returns>
/// List of data file container descriptors containing data items falling
/// into the specified range (<paramref name="rangeStart"/> - <paramref name="rangeEnd"/>)
/// </returns>
public List <IRepoFileContainerDescriptor> Enumerate(
IRepoFileContainerDescriptor root, int level)
{
if (null == root)
{
return(Enumerate(level));
}
// naturally this must be dropped/revised when adding more levels
Check.Require(root.Level == FolderLevelYear && level == FolderLevelMonth
, "Month level expected. Can only enumerate months in a year root in year-month scheme.");
return(EnumerateMonths(root));
}
internal List <IRepoFileContainerDescriptor> Enumerate(
IDirectoryProvider dirProvider, string rootPath, IRepoFileContainerDescriptor parent)
{
IEnumerable <string> allDirPaths = dirProvider.EnumerateDirectories(rootPath, DirNameMask);
List <IRepoFileContainerDescriptor> retval = new List <IRepoFileContainerDescriptor>();
foreach (string name in allDirPaths.Select((p) => dirProvider.GetLastPathComponent(p)))
{
IRepoFileContainerDescriptor descr = GetFolderDescriptor(parent, name);
if (null != descr)
{
retval.Add(descr);
}
}
return(retval);
}
/// <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);
}
private IRepoFileContainerDescriptor GetDescriptor(IRepoFileContainerDescriptor parentFolder, CalendarHistoricalFolderInternalDescriptor folder)
{
int level;
if (parentFolder == null)
{
level = RelativeTopLevelIndex;
}
else
{
level = parentFolder.Level - 1;
}
return(new RepoFileContainerDescriptor()
{
Start = folder.Start,
End = folder.End,
Level = level,
RelativePath = GetRelativePath(parentFolder, folder.Name)
});
}
/// <summary>
/// Enumerate descendant data folders in the [sub]tree with root at <see cref="RootPath"/>
/// </summary>
/// <param name="level">
/// Level at which to find data folders
/// 0 - leaf level
/// 1 - months
/// 2 - years
/// </param>
/// <returns>
/// List of data file container descriptors containing data items falling
/// into the specified range (<paramref name="rangeStart"/> - <paramref name="rangeEnd"/>)
/// </returns>
public List <IRepoFileContainerDescriptor> Enumerate(int level)
{
if (level < 0 || level >= this.LevelCount)
{
throw new ArgumentOutOfRangeException("level");
}
List <IRepoFileContainerDescriptor> retval = new List <IRepoFileContainerDescriptor>();
if (_directoryProvider.Exists(this.RootPath))
{
IEnumerable <string> yearDirs = _directoryProvider.EnumerateDirectories(
this.RootPath
, _dirLevelTraits[FolderLevelYear].DirNameMask);
foreach (string yearDir in yearDirs)
{
string dirName = _directoryProvider.GetLastPathComponent(yearDir);
int year = 0;
if (_dirLevelTraits[FolderLevelYear].IsValidDir(dirName, ref year))
{
IRepoFileContainerDescriptor descrYear =
_dirLevelTraits[FolderLevelYear].GetFolderDescriptorByRange(
new DateTime(year, 1, 1));
if (level == YearMonthHistoricalFoldersTraits.FolderLevelYear)
{
retval.Add(descrYear);
}
else // if (level == YearMonthHistoricalFoldersTraits.FolderLevelYear)
{
retval.AddRange(EnumerateMonths(descrYear));
} // else // if (level == YearMonthHistoricalFoldersTraits.FolderLevelYear)
} // if (_dirLevelTraits[FolderLevelYear].IsValidDir(yearDir.Name, ref year))
} // foreach (string yearDir in yearDirs)
} // if (root.Exists)
return(retval);
}
/// <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;
}
public CalendarHistoricalFolderInternalDescriptor GetDescriptor(IRepoFileContainerDescriptor parent, string folderName)
{
Check.Require(parent.Start == DayDataFolderTraits.GetRangeStartImpl(parent.Start) &&
parent.End.AddHours(-1) == parent.Start, "Parent of hour must be day");
return(GetDescriptor(parent.Start.Year, parent.Start.Month, parent.Start.Day, folderName));
}
public static int CompareFileContainers(
IRepoFileContainerDescriptor c1, IRepoFileContainerDescriptor c2)
{
return(DateTime.Compare(c1.Start, c1.Start));
}
/// <summary>
/// Get absolute path of a data folder
/// </summary>
/// <param name="folder">
/// Descriptor of the data folder; <see langword="null"/> considered data folders root.
/// </param>
/// <returns></returns>
private string GetAbsolutePath(IRepoFileContainerDescriptor folder)
{
return(GetAbsolutePath(folder == null ? string.Empty : folder.RelativePath));
}
/// <summary>
/// Get full path of a data folder by its descriptor
/// </summary>
/// <param name="dataFolder"></param>
/// <returns></returns>
private string GetFullPath(IRepoFileContainerDescriptor dataFolder)
{
return(Path.Combine(RootPath, dataFolder.RelativePath));
}
/// <summary>
/// Get descriptor of an [existing] folder by its name and parent folder.
/// </summary>
/// <param name="parent">
/// Descriptor of a parent folder
/// </param>
/// <param name="folderName">
/// The folder name
/// </param>
/// <returns>
/// <see langword="null"/> if the folder is not a valid historical data folder.
/// <see cref="CalendarHistoricalFolderInternalDescriptor"/> instance otherwise
/// </returns>
public CalendarHistoricalFolderInternalDescriptor GetDescriptor(IRepoFileContainerDescriptor parent, string folderName)
{
Check.Require(parent == null, "Year must be top level folder");
return(GetDescriptor(folderName));
}