public static async Task <MetaMetadataRepository> ReadDirectoryRecursively(MetaMetadataRepository mainRepo, String path, SimplTypesScope mmdTScope, SimplTypesScope metadataTScope)
{
Stack <string> stack = new Stack <string>();
stack.Push(path);
while (stack.Count > 0)
{
string dir = stack.Pop();
Debug.WriteLine("Looking in : " + dir);
//String[] files = Directory.GetFiles(dir, "*.xml");
string[] files = await FundamentalPlatformSpecifics.Get().GetFilesFromDirectory(dir, ".xml");
foreach (string file in files)
{
MetaMetadataRepository thatRepo = await ReadRepository(file, mmdTScope, metadataTScope, mainRepo);
// if (thatRepo != null)
// mainRepo.IntegrateRepository(thatRepo);
//string[] directories = Directory.GetDirectories(dir);
// string[] directories = await FundamentalPlatformSpecifics.Get().GetDirectoriesFromDirectory(dir);
// foreach (
// string innerDir in directories.Where(
// innerDir =>
// !innerDir.Contains(".svn")))
// stack.Push(innerDir);
// });
}
}
return(mainRepo);
}
public void FileConnect()
{
Task <Stream> streamTask = FundamentalPlatformSpecifics.Get().OpenFileReadStream(File);
streamTask.ContinueWith((task) =>
{
Stream = task.Result;
Good = true;
});
}
/// <summary>
///
/// </summary>
/// <param name="file"></param>
/// <param name="translationContext"></param>
/// <param name="deserializationHookStrategy"></param>
/// <param name="format"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public async Task <object> Deserialize(object file, TranslationContext translationContext, IDeserializationHookStrategy deserializationHookStrategy, Format format, Encoding encoding = null)
{
if (encoding == null)
{
encoding = Encoding.UTF8;
}
Stream readStream = await FundamentalPlatformSpecifics.Get().OpenFileReadStream(file, encoding);
return(Deserialize(readStream, translationContext, deserializationHookStrategy, format));
}
public void Reconnect()
{
if (PURL != null && PURL.IsFile && Stream == null)
{
try
{
Task <Stream> streamTask = FundamentalPlatformSpecifics.Get().OpenFileReadStream(File);
streamTask.ContinueWith((task) =>
{
Stream = task.Result;
});
}
catch (FileNotFoundException e)
{
Debug.WriteLine("ERROR: " + e);
}
}
}
public void NetworkConnect(IConnectionHelperJustRemote connectionHelper, String userAgent,
int connectionTimeout = ParsedUri.CONNECT_TIMEOUT,
int readTimeout = ParsedUri.READ_TIMEOUT)
{
FundamentalPlatformSpecifics.Get().NetworkConnect(connectionHelper, userAgent, this, connectionTimeout, readTimeout);
}
public void Connect(IConnectionHelper connectionHelper, String userAgent,
int connectionTimeout, int readTimeout)
{
// get an InputStream, and set the mimeType, if not bad
FundamentalPlatformSpecifics.Get().Connect(connectionHelper, userAgent, connectionTimeout, readTimeout, this);
}
/// <summary>
///
/// </summary>
/// <param name="url"></param>
public void parse(String url)
{
Task <StreamReader> streamReaderTask = FundamentalPlatformSpecifics.Get().GenerateStreamReaderFromFile(url);
streamReaderTask.ContinueWith((task) => parse(task.Result));
}
/// <summary>
/// Get MetaMetadata. First, try matching by url_base. If this fails, including if the attribute is
/// null, then try by url_prefix. If this fails, including if the attribute is null, then try by
/// url_pattern (regular expression).
/// <p/>
/// If that lookup fails, then lookup by tag name, to acquire the default.
/// </summary>
/// <param name="uri"></param>
/// <param name="tagName"></param>
/// <returns></returns>
public MetaMetadata GetDocumentMM(ParsedUri uri, String tagName = DocumentParserTagNames.DocumentTag)
{
MetaMetadata result = null;
if (uri != null)
{
if (!uri.IsFile)
{
//String noAnchorNoQueryPageString = uri.GetLeftPart(UriPartial.Path);
String noAnchorNoQueryPageString = FundamentalPlatformSpecifics.Get().GetUriLeftPart(uri);
_documentRepositoryByUrlStripped.TryGetValue(noAnchorNoQueryPageString, out result);
if (result == null)
{
//Check to see if the url prefix is actually a url-path tree.
//TODO: For url-path-tree cases, we should just generate a regex to handle those cases.
PrefixPhrase <MetaMetadata> matchingPrefix = urlPrefixCollection.getMatchingPrefix(uri);
if (matchingPrefix != null)
{
result = matchingPrefix.MappedObject;
}
}
if (result == null)
{
String domain = uri.Domain;
if (domain != null)
{
List <RepositoryPatternEntry> entries = null;
_documentRepositoryByPattern.TryGetValue(domain, out entries);
if (entries != null)
{
foreach (RepositoryPatternEntry entry in entries)
{
Match matcher = entry.Pattern.Match(uri.ToString());
if (matcher.Success)
{
result = entry.MetaMetadata;
break;
}
}
}
}
}
}
// be careful of the order! suffix before domain
if (result == null)
{
String suffix = uri.Suffix;
if (suffix != null)
{
result = GetMMBySuffix(suffix);
}
}
if (result == null)
{
String domain = uri.Domain;
_documentRepositoryByDomain.TryGetValue(domain, out result);
if (result != null)
{
Debug.WriteLine("Matched by domain = " + domain + "\t" + result);
}
}
}
if (result == null)
{
result = GetMMByName(tagName);
}
return(result);
}
public static async Task <MetaMetadataRepository> ReadRepository(string filename, SimplTypesScope mmdTScope, SimplTypesScope metadataTScope, MetaMetadataRepository mainRepo)
{
MetaMetadataRepository repo = null;
Debug.WriteLine("MetaMetadataRepository Reading:\t\t" + filename);
try
{
repo = await mmdTScope.DeserializeFile(filename, Format.Xml) as MetaMetadataRepository;
if (repo != null)
{
repo.MetadataTScope = metadataTScope;
repo.File = filename;
repo.InitializeSuffixAndMimeDicts();
if (repo.RepositoryByName == null)
{
return(repo);
}
foreach (var repoEntry in repo.RepositoryByName)
{
MetaMetadata mmd = repoEntry.Value;
string mmdName = repoEntry.Key;
//mmd.File = new FileInfo(filename);
mmd.File = await FundamentalPlatformSpecifics.Get().CreateFile(filename);
mmd.Parent = mainRepo;
mmd.Repository = mainRepo;
string packageName = mmd.PackageName ?? repo.PackageName;
if (packageName == null)
{
throw new MetaMetadataException("No Package Name Specified For " + mmd);
}
mmd.PackageName = packageName;
MmdScope packageMmdScopes;
mainRepo.PackageMmdScopes.TryGetValue(mmd.PackageName, out packageMmdScopes);
if (packageMmdScopes == null)
{
packageMmdScopes = new MmdScope(repo.PackageName);
packageMmdScopes.PutAll(mainRepo.RepositoryByName);
mainRepo.PackageMmdScopes.Put(packageName, packageMmdScopes);
}
MetaMetadata existingMmd;
switch (mmd.Visibility)
{
case Visibility.GLOBAL:
mainRepo.RepositoryByName.TryGetValue(mmdName, out existingMmd);
if (existingMmd != null && existingMmd != mmd)
{
throw new MetaMetadataException("MMD already exists: " + mmdName + " in " + filename);
}
mainRepo.RepositoryByName.Put(mmdName, mmd);
break;
case Visibility.PACKAGE:
Object mmdObj = null;
packageMmdScopes.TryGetValue(mmdName, out mmdObj);
existingMmd = (MetaMetadata)mmdObj;
if (existingMmd != null && existingMmd != mmd)
{
throw new MetaMetadataException("MMD already exists: " + mmdName + " in " + filename);
}
packageMmdScopes.Put(mmdName, mmd);
break;
}
}
foreach (MetaMetadata metaMetadata in repo.RepositoryByName.Values)
{
if (metaMetadata.PackageName == null)
{
Debug.WriteLine("No Package name defined for: " + metaMetadata.Name);
continue;
}
MmdScope packageMmdScope;
mainRepo.PackageMmdScopes.TryGetValue(metaMetadata.PackageName, out packageMmdScope);
metaMetadata.Scope = packageMmdScope;
}
mainRepo.IntegrateRepository(repo);
}
}
catch (Exception e)
{
Debug.WriteLine("Couldn't translate repository file: " + filename);
Debug.WriteLine(e);
}
return(repo);
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="file"></param>
/// <param name="translationContext"></param>
/// <param name="format"></param>
public async static Task Serialize(object obj, object file, TranslationContext translationContext, Format format)
{
Stream writeStream = await FundamentalPlatformSpecifics.Get().OpenFileWriteStream(file);
Serialize(obj, writeStream, translationContext, format);
}
/// <summary>
///
/// </summary>
/// <param name="filename"></param>
/// <param name="format"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public async Task <object> DeserializeFile(string filename, Format format, Encoding encoding = null)
{
object file = await FundamentalPlatformSpecifics.Get().CreateFile(filename);
return(await Deserialize(file, format));
}
