public PermutationContainerPPA CreatePermutation(Permutation permutation, PatternBasic positions,
ExtensionMap extensionMap)
{
return(new PermutationContainerPPA(permutation, positions,
new MinimumLettersChecked(avoidedPermutations), new ExMapComputationUnsorted(),
extensionMap, avoidedPermutations.LengthLongestPermutation));
}
public void SetResponse(string command, object data)
{
ResponseMap[command] = JsonConvert.SerializeObject(data);
if (ExtensionMap.ContainsKey(command))
{
ExtensionMap[command]();
}
if (PromiseMap.ContainsKey(command))
{
Promise.Promise promise = PromiseMap[command];
PromiseMap.Remove(command);
promise.Resolve();
}
Signals.ResponseHelper.Dispatch(command);
//dispatcher.Dispatch(commandType, command);
}
public void RemoveListen(string command)
{
command = command.Split('_')[1];
if (ExtensionMap.ContainsKey(command))
{
ExtensionMap.Remove(command);
}
}
private void ListenInner(string command, ExtensionCallback callback)
{
if (ExtensionMap.ContainsKey(command))
{
Debug.Log("Already listening command: " + command);
return;
}
ExtensionMap.Add(command, callback);
}
public PermutationContainerPPA(Permutation permutation, PatternBasic permutationPositions,
IMinimumLettersChecked minimumLettersBeChecked,
IExMapComputationUnsorted exMapComputationUnsorted,
ExtensionMap extensionMap,
int lengthLongestPermutationAvoided, int minimumLettersConsidered)
: this(permutation, permutationPositions,
minimumLettersBeChecked, exMapComputationUnsorted,
extensionMap, lengthLongestPermutationAvoided)
{
this.minimumLettersConsidered = minimumLettersConsidered;
}
public IPermutationsCollection Successors(Permutation permutation, ExtensionMap extensionMap,
IPermutationsCollection avoidedPermutations)
{
if (permutation.Length < avoidedPermutations.LengthLongestPermutation)
{
return(CreatePermutationsChecked(permutation, extensionMap, avoidedPermutations));
}
else
{
return(CreatePermutationsUnChecked(permutation, extensionMap));
}
}
public PermutationContainerPPA(Permutation permutation, PatternBasic permutationPositions,
IMinimumLettersChecked minimumLettersBeChecked,
IExMapComputationUnsorted exMapComputationUnsorted,
ExtensionMap extensionMap, int lengthLongestPermutationAvoided)
: base(permutation, permutationPositions)
{
minimumLettersConsidered = Math.Min(permutation.Length, lengthLongestPermutationAvoided);
countSuccessorsComputed = false;
this.minimumLettersBeChecked = minimumLettersBeChecked;
this.exMapComputationUnsorted = exMapComputationUnsorted;
this.extensionMap = extensionMap;
this.lengthLongestPermutationAvoided = lengthLongestPermutationAvoided;
}
/// <summary>
/// Opens an existing virtual disk.
/// </summary>
/// <param name="path">The path of the virtual disk to open, can be a URI</param>
/// <param name="access">The desired access to the disk</param>
/// <param name="user">The user name to use for authentication (if necessary)</param>
/// <param name="password">The password to use for authentication (if necessary)</param>
/// <returns>The Virtual Disk, or <c>null</c> if an unknown disk format</returns>
public static VirtualDisk OpenDisk(string path, FileAccess access, string user, string password)
{
Uri uri = PathToUri(path);
VirtualDisk result = null;
VirtualDiskTransport transport;
if (!DiskTransports.TryGetValue(uri.Scheme.ToUpperInvariant(), out transport))
{
throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Unable to parse path '{0}'", path), path);
}
try
{
transport.Connect(uri, user, password);
if (transport.IsRawDisk)
{
result = transport.OpenDisk(access);
}
else
{
string extension = Path.GetExtension(uri.AbsolutePath).ToUpperInvariant();
if (extension.StartsWith(".", StringComparison.Ordinal))
{
extension = extension.Substring(1);
}
VirtualDiskFactory factory;
if (ExtensionMap.TryGetValue(extension, out factory))
{
result = factory.OpenDisk(transport.GetFileLocator(), transport.GetFileName(), access);
}
}
if (result != null)
{
result._transport = transport;
transport = null;
}
return(result);
}
finally
{
if (transport != null)
{
transport.Dispose();
}
}
}
protected void CorrectExtensionMap(Permutation newPermutation, ExtensionMap extensionMap,
IPermutationsCollection avoidedPermutations)
{
for (int i = 0; i < extensionMap.Length; i++)
{
if (extensionMap.Get(i))
{
if (avoidedPermutations.Contains(newPermutation.InsertPosition(i)))
{
extensionMap.SetMutable(i, false);
}
}
}
}
public ExtensionMap Compute(IPermutationDictionary <ExtensionMap> permExMaps, Permutation permutation,
IPosition positions, int lettersConsidered)
{
ExtensionMap extensionMapDefault = extensionMapFactory.
GetExtensionMapDefault(permutation.Length + 1, true);
if (lettersConsidered <= 0)
{
return(extensionMapDefault);
}
ExtensionMap[] extensionMaps = new ExtensionMap[lettersConsidered];
int positionTo = positions.GetPosition(permutation.Length - 1);
Permutation newPermutation = permutation.Delete(positionTo, new int[] {});
permExMaps.TryGetValue(newPermutation, out ExtensionMap extensionMap);
extensionMap = extensionMap.Insert(positionTo, extensionMap.Get(positionTo));
extensionMaps[0] = extensionMap;
int positionFrom;
bool positionDiminished = false;
for (int i = 0; i < lettersConsidered - 1; i++)
{
positionFrom = positions.GetPosition(permutation.Length - i - 2);
if (positionFrom >= positionTo)
{
positionFrom--;
positionDiminished = true;
}
newPermutation = newPermutation.Switch(positionFrom, positionTo);
if (positionDiminished)
{
positionFrom++;
}
permExMaps.TryGetValue(newPermutation, out extensionMap);
extensionMap = extensionMap.Insert(positionFrom, extensionMap.Get(positionFrom));
extensionMaps[i + 1] = extensionMap;
positionTo = positionFrom;
positionDiminished = false;
}
return(extensionMapDefault.And(extensionMaps));
}
internal static VirtualDiskLayer OpenDiskLayer(FileLocator locator, string path, FileAccess access)
{
string extension = Path.GetExtension(path).ToUpperInvariant();
if (extension.StartsWith(".", StringComparison.Ordinal))
{
extension = extension.Substring(1);
}
VirtualDiskFactory factory;
if (ExtensionMap.TryGetValue(extension, out factory))
{
return(factory.OpenDiskLayer(locator, path, access));
}
return(null);
}
/// <summary>
/// Locates VirtualDiskFactory factories attributed with VirtualDiskFactoryAttribute, and types marked with VirtualDiskTransportAttribute, that are able to work with Virtual Disk types.
/// </summary>
/// <param name="assembly">An assembly to scan</param>
public static void RegisterVirtualDiskTypes(Assembly assembly)
{
foreach (Type type in assembly.GetTypes())
{
VirtualDiskFactoryAttribute diskFactoryAttribute = (VirtualDiskFactoryAttribute)ReflectionHelper.GetCustomAttribute(type, typeof(VirtualDiskFactoryAttribute), false);
if (diskFactoryAttribute != null)
{
VirtualDiskFactory factory = (VirtualDiskFactory)Activator.CreateInstance(type);
TypeMap.Add(diskFactoryAttribute.Type, factory);
foreach (string extension in diskFactoryAttribute.FileExtensions)
{
ExtensionMap.Add(extension.ToUpperInvariant(), factory);
}
}
VirtualDiskTransportAttribute diskTransportAttribute = ReflectionHelper.GetCustomAttribute(type, typeof(VirtualDiskTransportAttribute), false) as VirtualDiskTransportAttribute;
if (diskTransportAttribute != null)
{
DiskTransports.Add(diskTransportAttribute.Scheme.ToUpperInvariant(), type);
}
}
}
/// <summary>
/// Opens an existing virtual disk, possibly from within an existing disk.
/// </summary>
/// <param name="fs">The file system to open the disk on.</param>
/// <param name="path">The path of the virtual disk to open.</param>
/// <param name="access">The desired access to the disk.</param>
/// <returns>The Virtual Disk, or <c>null</c> if an unknown disk format.</returns>
public static VirtualDisk OpenDisk(DiscFileSystem fs, string path, FileAccess access)
{
if (fs == null)
{
return(OpenDisk(path, access));
}
string extension = Path.GetExtension(path).ToUpperInvariant();
if (extension.StartsWith(".", StringComparison.Ordinal))
{
extension = extension.Substring(1);
}
VirtualDiskFactory factory;
if (ExtensionMap.TryGetValue(extension, out factory))
{
return(factory.OpenDisk(fs, path, access));
}
return(null);
}
public static string GetExtension(string mime)
{
return(mime.IsNeu() ? mime : ExtensionMap.ToList().FirstOrDefault(x => x.Value == mime.ToLower()).Key);
}
private IPermutationsCollection CreatePermutationsChecked(Permutation permutation, ExtensionMap extensionMap,
IPermutationsCollection avoidedPermutations)
{
PermutationCollection permutationCollection = new PermutationCollection();
Permutation newPermutation;
foreach (var position in extensionMap.Ctz())
{
newPermutation = permutation.InsertPosition(position);
if (!avoidedPermutations.Contains(newPermutation))
{
permutationCollection.Add(newPermutation);
}
}
return(permutationCollection);
}
private IPermutationsCollection CreatePermutationsUnChecked(Permutation permutation, ExtensionMap extensionMap)
{
PermutationCollection permutationCollection = new PermutationCollection();
foreach (var position in extensionMap.Ctz())
{
permutationCollection.Add(permutation.InsertPosition(position));
}
return(permutationCollection);
}
