private void EnsurePath(SubAtlas atlas, string[] s, int index)
{
PackageNames.Add(atlas.Parent.Container.DisplayName);
var texturePackage = PackageManager.GetTexturePackageName(atlas.Parent.ReferencedTextureName);
if (texturePackage != null)
{
TexturePackageNames.Add(texturePackage);
}
if (index == s.Length)
{
// Leaf node.
if (Atlas == null || Atlas.Rect.Width < atlas.Rect.Width)
{
Atlas = atlas;
}
return;
}
// Branch node.
var folderToFind = s[index];
if (!SubFolders.ContainsKey(folderToFind))
{
AddDirectory(new TreeNode(folderToFind));
}
SubFolders[folderToFind].EnsurePath(atlas, s, index + 1);
}
public void ParseAssemblyAndRegisterRosServices(Assembly assembly)
{
foreach (Type type in assembly.GetTypes())
{
var typeInfo = type.GetTypeInfo();
if (type == typeof(RosService) || !typeInfo.IsSubclassOf(typeof(RosService)))
{
continue;
}
RosService service = Activator.CreateInstance(type) as RosService;
if (service.ServiceType == "undefined/unknown")
{
throw new Exception("Invalid servive type. Service type field (srvtype) was not initialized correctly.");
}
var packageName = service.ServiceType.Split('/')[0];
if (!PackageNames.Contains(packageName))
{
PackageNames.Add(packageName);
}
Logger.LogDebug($"Register {service.ServiceType}");
if (!TypeRegistry.ContainsKey(service.ServiceType))
{
TypeRegistry.Add(service.ServiceType, service.GetType());
}
}
}
protected void AddPackagesFromFile(IDictionary <string, string> variables)
{
if (SourceFile.IsNullOrWhiteSpace())
{
return;
}
var filename = ReplaceVariablesInString(this.SourceFile, variables);
if (PackageNames != null)
{
PackageNames = new List <string>();
}
if (System.IO.File.Exists(filename) == false)
{
throw new ArgumentException($"The source file '{filename}' for a '{this.GetType().Name}' does not exist.");
}
var names = System.IO.File.ReadAllLines(filename);
foreach (var name in names)
{
PackageNames.Add(name);
}
}
public async Task <Stream> Put()
{
if (packageName == null)
{
throw new InvalidOperationException();
}
await PackageNames.Add(packageName);
itemFile.EnsureParent();
return(itemFile.OpenWrite());
}
private async Task PreparePut()
{
if (packageName == null)
{
throw new InvalidOperationException();
}
//TODO: request even if container exists
await itemBlob.CreateContainerIfNotExistsAsync();
await PackageNames.Add(packageName);
}
public IntPtr GetAddress()
{
if (address == IntPtr.Zero)
{
return(address);
}
using (TArrayUnsafe <FName> packageNamesUnsafe = new TArrayUnsafe <FName>())
{
packageNamesUnsafe.AddRange(PackageNames.ToArray());
Native_FARFilter.Set_PackageNames(address, packageNamesUnsafe.Address);
}
using (TArrayUnsafe <FName> packagePathsUnsafe = new TArrayUnsafe <FName>())
{
packagePathsUnsafe.AddRange(PackagePaths.ToArray());
Native_FARFilter.Set_PackagePaths(address, packagePathsUnsafe.Address);
}
using (TArrayUnsafe <FName> objectPathsUnsafe = new TArrayUnsafe <FName>())
{
objectPathsUnsafe.AddRange(ObjectPaths.ToArray());
Native_FARFilter.Set_ObjectPaths(address, objectPathsUnsafe.Address);
}
using (TArrayUnsafe <FName> classNamesUnsafe = new TArrayUnsafe <FName>())
{
classNamesUnsafe.AddRange(ClassNames.ToArray());
Native_FARFilter.Set_ClassNames(address, classNamesUnsafe.Address);
}
using (TArrayUnsafe <FName> tagsUnsafe = new TArrayUnsafe <FName>())
using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>())
{
tagsUnsafe.AddRange(TagsAndValues.Keys.ToArray());
valuesUnsafe.AddRange(TagsAndValues.Values.ToArray());
Native_FARFilter.Set_TagsAndValues(address, tagsUnsafe.Address, valuesUnsafe.Address);
}
using (TArrayUnsafe <FName> recursiveClassesExclusionSet = new TArrayUnsafe <FName>())
{
recursiveClassesExclusionSet.AddRange(RecursiveClassesExclusionSet.ToArray());
Native_FARFilter.Set_RecursiveClassesExclusionSet(address, recursiveClassesExclusionSet.Address);
}
Native_FARFilter.Set_bRecursivePaths(address, RecursivePaths);
Native_FARFilter.Set_bRecursiveClasses(address, RecursiveClasses);
Native_FARFilter.Set_bIncludeOnlyOnDiskAssets(address, IncludeOnlyOnDiskAssets);
return(address);
}
public async Task <bool> Delete()
{
if (packageName == null)
{
throw new InvalidOperationException();
}
await PackageNames.Remove(packageName);
if (!(await PackageNames.List()).Any())
{
return(itemFile.Delete());
}
return(false);
}
public bool IsMatch(ModNetworkContent c) => c.Publishers.Any(x => Publishers.Any(p => p.Id == x.PublisherId && p.Type == x.Publisher)) || PackageNames.ContainsIgnoreCase(c.PackageName) || Ids.Contains(c.Id);
public bool IsMatch(ModClientApiJsonV3WithGameId c) => c.Publishers.Any(x => Publishers.Any(p => p.Id == x.Id && p.Type == x.Type)) || PackageNames.ContainsIgnoreCase(c.PackageName) || Ids.Contains(c.Id);
public void ParseAssemblyAndRegisterRosMessages(Assembly assembly)
{
foreach (Type othertype in assembly.GetTypes())
{
var messageInfo = othertype.GetTypeInfo();
if (othertype == typeof(RosMessage) || !messageInfo.IsSubclassOf(typeof(RosMessage)) || othertype == typeof(InnerActionMessage))
{
continue;
}
var goalAttribute = messageInfo.GetCustomAttribute <ActionGoalMessageAttribute>();
var resultAttribute = messageInfo.GetCustomAttribute <ActionResultMessageAttribute>();
var feedbackAttribute = messageInfo.GetCustomAttribute <ActionFeedbackMessageAttribute>();
var ignoreAttribute = messageInfo.GetCustomAttribute <IgnoreRosMessageAttribute>();
RosMessage message;
if (goalAttribute != null || resultAttribute != null || feedbackAttribute != null || ignoreAttribute != null)
{
Type actionType;
if (goalAttribute != null)
{
actionType = typeof(GoalActionMessage <>);
}
else if (resultAttribute != null)
{
actionType = typeof(ResultActionMessage <>);
}
else if (feedbackAttribute != null)
{
actionType = typeof(FeedbackActionMessage <>);
}
else if (ignoreAttribute != null)
{
continue;
}
else
{
throw new InvalidOperationException($"Could create Action Message for {othertype}");
}
Type[] innerType = { othertype };
var goalMessageType = actionType.MakeGenericType(innerType);
message = (Activator.CreateInstance(goalMessageType)) as RosMessage;
}
else
{
message = Activator.CreateInstance(othertype) as RosMessage;
if ((message != null) && (message.MessageType == "undefined/unknown"))
{
throw new Exception("Invalid message type. Message type field (msgtype) was not initialized correctly.");
}
}
var packageName = message.MessageType.Split('/')[0];
if (!PackageNames.Contains(packageName))
{
PackageNames.Add(packageName);
}
Logger.LogDebug($"Register {message.MessageType}");
if (!TypeRegistry.ContainsKey(message.MessageType))
{
TypeRegistry.Add(message.MessageType, message.GetType());
}
else
{
var messageFromRegistry = CreateMessage(message.MessageType);
if (messageFromRegistry.MD5Sum() != message.MD5Sum())
{
throw new InvalidOperationException($"The message of type {message.MessageType} has already been " +
$"registered and the MD5 sums do not match. Already registered: {messageFromRegistry.MD5Sum()} " +
$"new message: {message.MD5Sum()}.");
}
else
{
Logger.LogDebug($"The message of type {message.MessageType} has already been registered. Since the" +
"MD5 sums do match, the new message is ignored.");
}
}
}
}
