public PackageViewModel(PackageReader reader) { _reader = reader; SourcePackageViewModel=new PackageViewModel() { Name = reader.GetRulesSourcePropertyValueByName(Package, "name"), DisplayName = reader.GetRulesSourcePropertyValueByName(Package, "display-name"), Architecture = reader.GetRulesSourcePropertyValueByName(Package, "arch"), Feed = reader.GetRulesSourcePropertyValueByName(Package, "feed"), Location = reader.GetRulesSourcePropertyValueByName(Package, "location"), Publisher = reader.GetRulesSourcePropertyValueByName(Package, "publisher"), Version = reader.GetRulesSourcePropertyValueByName(Package, "version"), IsEditable = true, IsSource = true, }; Name = reader.GetRulesPropertyValueByName(Package, "name"); DisplayName = reader.GetRulesPropertyValueByName(Package, "display-name"); Architecture = reader.GetRulesPropertyValueByName(Package, "arch"); Feed = reader.GetRulesPropertyValueByName(Package, "feed"); Location = reader.GetRulesPropertyValueByName(Package, "location"); Publisher = reader.GetRulesPropertyValueByName(Package, "publisher"); Version = reader.GetRulesPropertyValueByName(Package, "version"); IsEditable = false; SourceString = reader.GetRulesSourceStringPropertyValueByName(Package); SourcePackageViewModel.PropertyChanged += EvaluatedChanged; }
public void PackageReader_LegacyFolders() { // Verify legacy folder names such as 40 and 35 parse to frameworks var zip = TestPackages.GetZip(TestPackages.GetLegacyFolderPackage()); using (PackageReader reader = new PackageReader(zip)) { var groups = reader.GetReferenceItems().ToArray(); Assert.Equal(4, groups.Count()); Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework); Assert.Equal("lib/a.dll", groups[0].Items.ToArray()[0]); Assert.Equal(NuGetFramework.Parse("net35"), groups[1].TargetFramework); Assert.Equal("lib/35/b.dll", groups[1].Items.ToArray()[0]); Assert.Equal(NuGetFramework.Parse("net4"), groups[2].TargetFramework); Assert.Equal("lib/40/test40.dll", groups[2].Items.ToArray()[0]); Assert.Equal("lib/40/x86/testx86.dll", groups[2].Items.ToArray()[1]); Assert.Equal(NuGetFramework.Parse("net45"), groups[3].TargetFramework); Assert.Equal("lib/45/a.dll", groups[3].Items.ToArray()[0]); } }
public MetadataViewModel(PackageReader reader) { _reader = reader; Summary = reader.GetRulesPropertyValueByName(Metadata, "summary"); Description = reader.GetRulesPropertyValueByName(Metadata, "description"); AuthorVersion = reader.GetRulesPropertyValueByName(Metadata, "author-version"); BugTracker = reader.GetRulesPropertyValueByName(Metadata, "bug-tracker"); Stability = reader.GetRulesPropertyValueByName(Metadata, "stability"); Licenses = reader.GetRulesPropertyValueByName(Metadata, "licenses"); IsEditable = false; SourceMetadataViewModel = new MetadataViewModel() { Summary = reader.GetRulesSourcePropertyValueByName(Metadata, "summary"), Description = reader.GetRulesSourcePropertyValueByName(Metadata, "description"), AuthorVersion = reader.GetRulesSourcePropertyValueByName(Metadata, "author-version"), BugTracker = reader.GetRulesSourcePropertyValueByName(Metadata, "bug-tracker"), Stability = reader.GetRulesSourcePropertyValueByName(Metadata, "stability"), Licenses = reader.GetRulesSourcePropertyValueByName(Metadata, "licenses"), IsEditable = true, IsSource = true, }; SourceString = reader.GetRulesSourceStringPropertyValueByName(Metadata); SourceMetadataViewModel.PropertyChanged += EvaluatedChanged; }
//withparam name? public AssemblyRoleViewModel(PackageReader reader) : base() { // Root = root; ApplicationCollection = new ObservableCollection<ApplicationItemViewModel>(); foreach (string parameter in reader.ReadParameters("assembly")) { ObservableCollection<ItemViewModel> includeCollection = new ObservableCollection<ItemViewModel>(reader.ApplicationIncludeList("assembly", parameter, "include")); ApplicationItemViewModel model = new ApplicationItemViewModel() { Label = "Assembly", EditCollectionViewModel = new EditCollectionViewModel(reader, includeCollection), Name = parameter, // Root = root, }; ApplicationCollection.Add(model); } SourceString = reader.GetRulesSourceStringPropertyValueByName("assembly"); ApplicationCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(base.FilesCollectionCollectionChanged); }
public PackageCompositionViewModel(PackageReader reader) { // List<string> parameters = reader.ReadPackageCompositionParameters(); // string a = reader.GetRulesPropertyValuesByNameForSigning("package-composition", "symlinks", "exes"); // Symlinks = reader.GetRulesPropertyValuesByNameForSigning("package-composition", "symlinks", "exes"); SourceString = reader.GetRulesSourceStringPropertyValueByName("package-composition"); }
public RequiresViewModel(PackageReader reader) { EditCollectionViewModel = new EditCollectionViewModel(reader, reader.GetRulesSourceValuesByNameForEditableCollections( "requires", "package")); SourceString = reader.GetRulesSourceStringPropertyValueByName("requires"); }
public OnlineStage(Socket socket, AgentCore core) { _Core = core; _Socket = socket; _Reader = new PackageReader<ResponsePackage>(); _Writer = new PackageWriter<RequestPackage>(OnlineStage.LowFps); _Sends = new Collection.Queue<RequestPackage>(); _Receives = new Collection.Queue<ResponsePackage>(); }
public new void InstallSecurity(string path, IProcessingContext context) { Assert.ArgumentNotNullOrEmpty(path, "path"); Assert.ArgumentNotNull((object)context, "context"); Log.Info("Installing security from package: " + path, (object)this); PackageReader packageReader = new PackageReader(path); AccountInstaller accountInstaller = new AccountInstaller(); accountInstaller.Initialize(context); packageReader.Populate((ISink<PackageEntry>)accountInstaller); accountInstaller.Flush(); accountInstaller.Finish(); }
public EditCollectionViewModel(PackageReader reader, ObservableCollection<ItemViewModel> collection) { _reader = reader; // Root = root; _editableItems = collection; if(this.EditableItems.Count>0) { _updateSource = this.EditableItems.FirstOrDefault().UpdateSource; } _editableItems.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged); }
public Peer(Socket client) { _EnableLock = new object(); _Socket = client; _SoulProvider = new SoulProvider(this, this); _Responses = new Regulus.Collection.Queue<ResponsePackage>(); _Requests = new Regulus.Collection.Queue<RequestPackage>(); _Enable = true; _Reader = new PackageReader<RequestPackage>(); _Writer = new PackageWriter<ResponsePackage>(); }
public SigningViewModel(PackageReader reader) { _reader = reader; ReplaceSignature = _reader.GetRulesPropertyValueByName(Signing, "replace-signature") == "true"; CompanyAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "company",false); DescriptionAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "description",false); ProductNameAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "product-name",false); ProductVersion = reader.GetRulesByNameForSigning(Signing, "attributes", "product-version",false); FileVersionAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "file-version",false); EditCollectionViewModel = new EditCollectionViewModel(reader, reader.GetRulesSourceValuesByNameForEditableCollections(Signing, "include")); IsEditable = false; IsReadOnly = true; SourceSigningViewModel = new SigningViewModel() { ReplaceSignature = _reader.GetRulesSourcePropertyValueByName(Signing, "replace-signature") == "true", CompanyAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "company", true), DescriptionAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "description", true), ProductNameAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "product-name", true), ProductVersion = reader.GetRulesByNameForSigning(Signing, "attributes", "product-version", true), FileVersionAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "file-version", true), EditCollectionViewModel = this.EditCollectionViewModel, IsEditable = true, IsReadOnly = false, IsSource = true, }; SourceString = reader.GetRulesSourceStringPropertyValueByName(Signing); SourceSigningViewModel.PropertyChanged += EvaluatedChanged; }
public FilesViewModel(PackageReader reader) { _filesCollection = new ObservableCollection<FilesItemViewModel>(); foreach (string parameter in reader.ReadParameters("files")) { ObservableCollection<ItemViewModel> includeCollection = new ObservableCollection<ItemViewModel>(reader.GetRulesSourceValuesByParameterForEditableCollections("files", parameter, "include")); FilesItemViewModel model = new FilesItemViewModel() { FilesRoot = reader.GetFilesRulesPropertyValueByParameterAndName(parameter, "root"), TrimPath = reader.GetFilesRulesPropertyValueByParameterAndName(parameter, "trim-path"), EditCollectionViewModel = new EditCollectionViewModel(reader, includeCollection), Name = parameter, }; _filesCollection.Add(model); } SourceString = reader.GetRulesSourceStringPropertyValueByName("files"); _filesCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged); }
public ManifestViewModel(PackageReader reader) { _manifestCollection = new ObservableCollection<ManifestItemViewModel>(); foreach (string parameter in reader.ReadParameters("manifest")) { var includeCollection = new ObservableCollection<ItemViewModel>(reader.GetRulesSourceValuesByParameterForEditableCollections("manifest", parameter, "include")); var assemblyCollection = new ObservableCollection<ItemViewModel>(reader.GetRulesSourceValuesByParameterForEditableCollections("manifest", parameter, "assembly")); var model = new ManifestItemViewModel() { AssemblyCollection = new EditCollectionViewModel(reader, assemblyCollection), IncludeCollection = new EditCollectionViewModel(reader, includeCollection), Name = parameter, }; _manifestCollection.Add(model); } SourceString = reader.GetRulesSourceStringPropertyValueByName("manifest"); _manifestCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged); }
public void PackageReader_RespectReferencesAccordingToDifferentFrameworks() { // Copy of the InstallPackageRespectReferencesAccordingToDifferentFrameworks functional test // Arrange var zip = TestPackages.GetZip(TestPackages.GetNearestReferenceFilteringPackage()); var reader = new PackageReader(zip); // Act var references = reader.GetReferenceItems(); var netResult = NuGetFrameworkUtility.GetNearest<FrameworkSpecificGroup>(references, NuGetFramework.Parse("net45")); var slResult = NuGetFrameworkUtility.GetNearest<FrameworkSpecificGroup>(references, NuGetFramework.Parse("sl5")); // Assert Assert.Equal(2, netResult.Items.Count()); Assert.Equal(1, slResult.Items.Count()); Assert.Equal("lib/sl40/a.dll", slResult.Items.First()); Assert.Equal("lib/net40/one.dll", netResult.Items.First()); Assert.Equal("lib/net40/three.dll", netResult.Items.Skip(1).First()); }
public CompatibilityPolicyViewModel(PackageReader reader) { _reader = reader; Minimum = reader.GetRulesPropertyValueByName(CompatibilityPolicy, "minimum"); Maximum = reader.GetRulesPropertyValueByName(CompatibilityPolicy, "maximum"); Versions = reader.GetRulesPropertyValueByName(CompatibilityPolicy, "versions"); IsEditable = false; SourceValueCompatibilityPolicyViewModel = new CompatibilityPolicyViewModel() { Minimum = reader.GetRulesSourcePropertyValueByName(CompatibilityPolicy, "minimum"), Maximum = reader.GetRulesSourcePropertyValueByName(CompatibilityPolicy, "maximum"), Versions = reader.GetRulesSourcePropertyValueByName(CompatibilityPolicy, "versions"), IsEditable = true, IsSource = true, }; SourceString = reader.GetRulesSourceStringPropertyValueByName(CompatibilityPolicy); SourceValueCompatibilityPolicyViewModel.PropertyChanged += EvaluatedChanged; }
public void PackageFolderReader_Basic() { var packageNupkg = TestPackages.GetLegacyTestPackage(); var zip = new ZipArchive(packageNupkg.OpenRead()); PackageReader zipReader = new PackageReader(zip); var folder = Path.Combine(packageNupkg.Directory.FullName, Guid.NewGuid().ToString()); var zipFile = new ZipArchive(File.OpenRead(packageNupkg.FullName)); zipFile.ExtractAll(folder); var folderReader = new PackageFolderReader(folder); Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer()); Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count()); Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count()); Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First()); }
public LicenseViewModel(PackageReader reader) { _reader = reader; License = reader.GetRulesPropertyValueByName(LicenseString, "license"); LicenseType = reader.GetRulesPropertyValueByName(LicenseString, "license-type"); LicenseUrl = reader.GetRulesPropertyValueByName(LicenseString, "license-url"); _sourceValueLicenseViewModel = new LicenseViewModel() { License = reader.GetRulesSourcePropertyValueByName(LicenseString, "license"), LicenseType = reader.GetRulesSourcePropertyValueByName(LicenseString, "license-type"), LicenseUrl = reader.GetRulesSourcePropertyValueByName(LicenseString, "license-url"), IsEditable = true, IsSource = true, }; SourceString = reader.GetRulesSourceStringPropertyValueByName(LicenseString); SourceValueLicenseViewModel.PropertyChanged += EvaluatedChanged; }
public ApplicationRoleViewModel(PackageReader reader) { _applicationCollection = new ObservableCollection<RoleItemViewModel>(); foreach (string parameter in reader.ReadParameters("application")) { var includeCollection = new ObservableCollection<ItemViewModel>(reader.ApplicationIncludeList("application", parameter, "include")); var model = new RoleItemViewModel() { Label = "Application", EditCollectionViewModel = new EditCollectionViewModel(reader, includeCollection), Name = parameter, }; _applicationCollection.Add(model); } SourceString = reader.GetRulesSourceStringPropertyValueByName("application"); _applicationCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged); }
public void PackageReader_NestedReferenceItemsMixed() { var zip = TestPackages.GetZip(TestPackages.GetLibEmptyFolderPackage()); using (PackageReader reader = new PackageReader(zip)) { var groups = reader.GetReferenceItems().ToArray(); Assert.Equal(3, groups.Count()); Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework); Assert.Equal(2, groups[0].Items.Count()); Assert.Equal("lib/a.dll", groups[0].Items.ToArray()[0]); Assert.Equal("lib/x86/b.dll", groups[0].Items.ToArray()[1]); Assert.Equal(NuGetFramework.Parse("net40"), groups[1].TargetFramework); Assert.Equal(2, groups[1].Items.Count()); Assert.Equal("lib/net40/test40.dll", groups[1].Items.ToArray()[0]); Assert.Equal("lib/net40/x86/testx86.dll", groups[1].Items.ToArray()[1]); Assert.Equal(NuGetFramework.Parse("net45"), groups[2].TargetFramework); Assert.Equal(0, groups[2].Items.Count()); } }
public void PackageReader_ReferencesWithoutGroups() { var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackageWithPre25References()); using (PackageReader reader = new PackageReader(zip)) { var groups = reader.GetReferenceItems().ToArray(); Assert.Equal(3, groups.Count()); Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework); Assert.Equal(1, groups[0].Items.Count()); Assert.Equal("lib/test.dll", groups[0].Items.Single()); Assert.Equal(NuGetFramework.Parse("net40"), groups[1].TargetFramework); Assert.Equal(1, groups[1].Items.Count()); Assert.Equal("lib/net40/test.dll", groups[1].Items.Single()); Assert.Equal(NuGetFramework.Parse("net451"), groups[2].TargetFramework); Assert.Equal(1, groups[1].Items.Count()); Assert.Equal("lib/net451/test.dll", groups[2].Items.Single()); } }
internal UTexture2D(PackageReader reader, Stream ubulk, long bulkOffset) : base(reader) { Serialize(reader, ubulk, bulkOffset); }
internal static void Validate(PackageValidatorSettings packageValidatorSettings, PackageReader packageReader, bool logReplacement, ValidationResults log, ManifestReaderSettings manifestSettings, bool fixLrmViolations, out ManifestReader manifestReader) { ValidatorResources.Culture = Thread.CurrentThread.CurrentCulture;; if (packageReader == null) { throw new ArgumentNullException("packageReader"); } ValidationResults manifestLog; XPathNavigator manifest; packageReader.CreateManifestNavigator(packageValidatorSettings.LrmRequirementValidation, fixLrmViolations, out manifestLog, out manifest); if (manifestLog != null) { foreach (ValidationResult result in manifestLog.Results) { log.AddResult(result); } } manifestReader = new ManifestReader(packageReader, manifestSettings, packageValidatorSettings, logReplacement, log, manifest); if (packageValidatorSettings.MlcRequirementValidation != ValidationBehavior.None) { int activityCount = 0; if (manifestReader.Organizations.Count > 0) { foreach (OrganizationNodeReader nodeReader in manifestReader.Organizations) { activityCount += nodeReader.Activities.Count; } if (activityCount == 0) { ProcessError(packageValidatorSettings.MlcRequirementValidation, ValidatorResources.MlcViolationActivityMissing, log); } } else { ProcessError(packageValidatorSettings.MlcRequirementValidation, ValidatorResources.MlcViolationOrganizationMissing, log); } } ManifestValidator.Validate(manifestReader); // Add all files in the manifest to a Dictionary Dictionary <string, bool> manifestFilePaths = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase); foreach (ResourceNodeReader r in manifestReader.Resources.Values) { foreach (FileNodeReader fileNode in r.Files) { if (!fileNode.Location.IsAbsoluteUri) { // get the path component of the Location property, and URL decode the string // so it is a proper file path. string path = System.Web.HttpUtility.UrlDecode(RemoveQueryAndAnchor(fileNode.Location.OriginalString)); if (!manifestFilePaths.ContainsKey(path)) { manifestFilePaths.Add(path, true); } } } } ReadOnlyCollection <string> packageFilePaths = packageReader.GetFilePaths(); CheckManifestFiles(packageFilePaths, manifestFilePaths, log, packageValidatorSettings); CheckPackageFiles(packageFilePaths, manifestFilePaths, log, packageValidatorSettings); }
public void PackageReader_ContentNoFrameworks() { var zip = TestPackages.GetZip(TestPackages.GetLegacyContentPackage()); using (PackageReader reader = new PackageReader(zip)) { var groups = reader.GetContentItems().ToArray(); Assert.Equal(1, groups.Count()); Assert.Equal(NuGetFramework.AnyFramework, groups.Single().TargetFramework); Assert.Equal(3, groups.Single().Items.Count()); } }
public UObject(PackageReader reader, bool structFallback) : this(reader, reader.ExportMap.Sum(e => e.SerialSize), structFallback) { }
// https://github.com/EpicGames/UnrealEngine/blob/bf95c2cbc703123e08ab54e3ceccdd47e48d224a/Engine/Source/Runtime/CoreUObject/Private/UObject/Class.cpp#L930 public UObject(PackageReader reader) : this(reader, reader.ExportMap.Sum(e => e.SerialSize), false) { }
public static void OnAssetLoadedImpl(string name, object asset, Dictionary <string, byte[]> userData) { if (!userData.TryGetValue(DataKey, out var bytes)) { return; } Debug.Log($"Found custom effect data for {name}"); var propEffectsDict = new Dictionary <string, PropInfo.Effect[]>(); var vehicleEffectsDict = new Dictionary <string, VehicleInfo.Effect[]>(); using (var stream = new MemoryStream(bytes)) { using (var reader = new PackageReader(stream)) { var propEffectsDictCount = reader.ReadInt32(); for (var p = 0; p < propEffectsDictCount; p++) { var prefabName = reader.ReadString(); var effectCount = reader.ReadInt32(); var propEffects = new List <PropInfo.Effect>(effectCount); for (var e = 0; e < effectCount; e++) { var effectName = reader.ReadString(); var propEffect = new PropInfo.Effect { m_effect = EffectCollection.FindEffect(effectName), m_position = reader.ReadVector3(), m_direction = reader.ReadVector3() }; if (propEffect.m_effect != null) { propEffects.Add(propEffect); Debug.LogError($"Adding effect \"{effectName}\" for ${prefabName}"); } else { Debug.LogError($"Effect \"{effectName}\" not found while loading {prefabName}!"); } } propEffectsDict[prefabName] = propEffects.ToArray(); } var vehicleEffectsDictCount = reader.ReadInt32(); for (var v = 0; v < vehicleEffectsDictCount; v++) { var prefabName = reader.ReadString(); var effectCount = reader.ReadInt32(); var propEffects = new List <VehicleInfo.Effect>(effectCount); for (var e = 0; e < effectCount; e++) { var effectName = reader.ReadString(); var vehicleEffect = new VehicleInfo.Effect { m_effect = EffectCollection.FindEffect(effectName), m_vehicleFlagsRequired = (Vehicle.Flags)reader.ReadInt32(), m_vehicleFlagsForbidden = (Vehicle.Flags)reader.ReadInt32(), m_parkedFlagsRequired = (VehicleParked.Flags)reader.ReadInt32(), m_parkedFlagsForbidden = (VehicleParked.Flags)reader.ReadInt32() }; if (vehicleEffect.m_effect != null) { propEffects.Add(vehicleEffect); } else { Debug.LogError($"Effect \"{effectName}\" not found while loading {prefabName}!"); } } vehicleEffectsDict[prefabName] = propEffects.ToArray(); } } } if (asset is PropInfo propPrefab) { ApplyCustomEffects(propPrefab, propEffectsDict); if (propPrefab.m_variations != null) { foreach (var variation in propPrefab.m_variations) { ApplyCustomEffects(variation.m_prop, propEffectsDict); } } } else if (asset is VehicleInfo vehiclePrefab) { ApplyCustomEffects(vehiclePrefab, vehicleEffectsDict); if (vehiclePrefab.m_trailers != null) { foreach (var trailer in vehiclePrefab.m_trailers) { ApplyCustomEffects(trailer.m_info, vehicleEffectsDict); } } } }
internal FCompressedOffsetData(PackageReader reader) { OffsetData = reader.ReadTArray(() => reader.ReadInt32()); StripSize = reader.ReadInt32(); }
private LockFileTargetLibrary CreateLockFileTargetLibrary(LocalPackageInfo package, RestoreTargetGraph targetGraph, DefaultPackagePathResolver defaultPackagePathResolver, string correctedPackageName) { var lockFileLib = new LockFileTargetLibrary(); var framework = targetGraph.Framework; var runtimeIdentifier = targetGraph.RuntimeIdentifier; // package.Id is read from nuspec and it might be in wrong casing. // correctedPackageName should be the package name used by dependency graph and // it has the correct casing that runtime needs during dependency resolution. lockFileLib.Name = correctedPackageName ?? package.Id; lockFileLib.Version = package.Version; IList <string> files; var contentItems = new ContentItemCollection(); HashSet <string> referenceFilter = null; using (var nupkgStream = File.OpenRead(package.ZipPath)) { var packageReader = new PackageReader(nupkgStream); files = packageReader.GetFiles().Select(p => p.Replace(Path.DirectorySeparatorChar, '/')).ToList(); contentItems.Load(files); var dependencySet = packageReader.GetPackageDependencies().GetNearest(framework); if (dependencySet != null) { var set = dependencySet.Packages; if (set != null) { lockFileLib.Dependencies = set.ToList(); } } var referenceSet = packageReader.GetReferenceItems().GetNearest(framework); if (referenceSet != null) { referenceFilter = new HashSet <string>(referenceSet.Items, StringComparer.OrdinalIgnoreCase); } // TODO: Remove this when we do #596 // ASP.NET Core isn't compatible with generic PCL profiles if (!string.Equals(framework.Framework, FrameworkConstants.FrameworkIdentifiers.AspNetCore, StringComparison.OrdinalIgnoreCase) && !string.Equals(framework.Framework, FrameworkConstants.FrameworkIdentifiers.DnxCore, StringComparison.OrdinalIgnoreCase)) { var frameworkAssemblies = packageReader.GetFrameworkItems().GetNearest(framework); if (frameworkAssemblies != null) { foreach (var assemblyReference in frameworkAssemblies.Items) { lockFileLib.FrameworkAssemblies.Add(assemblyReference); } } } } var nativeCriteria = targetGraph.Conventions.Criteria.ForRuntime(targetGraph.RuntimeIdentifier); var managedCriteria = targetGraph.Conventions.Criteria.ForFrameworkAndRuntime(framework, targetGraph.RuntimeIdentifier); var compileGroup = contentItems.FindBestItemGroup(managedCriteria, targetGraph.Conventions.Patterns.CompileAssemblies, targetGraph.Conventions.Patterns.RuntimeAssemblies); if (compileGroup != null) { lockFileLib.CompileTimeAssemblies = compileGroup.Items.Select(t => new LockFileItem(t.Path)).ToList(); } var runtimeGroup = contentItems.FindBestItemGroup(managedCriteria, targetGraph.Conventions.Patterns.RuntimeAssemblies); if (runtimeGroup != null) { lockFileLib.RuntimeAssemblies = runtimeGroup.Items.Select(p => new LockFileItem(p.Path)).ToList(); } var resourceGroup = contentItems.FindBestItemGroup(managedCriteria, targetGraph.Conventions.Patterns.ResourceAssemblies); if (resourceGroup != null) { lockFileLib.ResourceAssemblies = resourceGroup.Items.Select(ToResourceLockFileItem).ToList(); } var nativeGroup = contentItems.FindBestItemGroup(nativeCriteria, targetGraph.Conventions.Patterns.NativeLibraries); if (nativeGroup != null) { lockFileLib.NativeLibraries = nativeGroup.Items.Select(p => new LockFileItem(p.Path)).ToList(); } // COMPAT: Support lib/contract so older packages can be consumed var contractPath = "lib/contract/" + package.Id + ".dll"; var hasContract = files.Any(path => path == contractPath); var hasLib = lockFileLib.RuntimeAssemblies.Any(); if (hasContract && hasLib && !framework.IsDesktop()) { lockFileLib.CompileTimeAssemblies.Clear(); lockFileLib.CompileTimeAssemblies.Add(new LockFileItem(contractPath)); } // Apply filters from the <references> node in the nuspec if (referenceFilter != null) { // Remove anything that starts with "lib/" and is NOT specified in the reference filter. // runtimes/* is unaffected (it doesn't start with lib/) lockFileLib.RuntimeAssemblies = lockFileLib.RuntimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(p.Path)).ToList(); lockFileLib.CompileTimeAssemblies = lockFileLib.CompileTimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(p.Path)).ToList(); } return(lockFileLib); }
// https://github.com/EpicGames/UnrealEngine/blob/bf95c2cbc703123e08ab54e3ceccdd47e48d224a/Engine/Source/Runtime/CoreUObject/Private/UObject/Class.cpp#L930 public UObject(PackageReader reader) : this(reader, false) { }
private void WriteTargetsAndProps(PackageSpec project, List <RestoreTargetGraph> targetGraphs, NuGetv3LocalRepository repository) { // Get the runtime-independent graphs var tfmGraphs = targetGraphs.Where(g => string.IsNullOrEmpty(g.RuntimeIdentifier)).ToList(); if (tfmGraphs.Count > 1) { var name = $"{project.Name}.nuget.targets"; var path = Path.Combine(project.BaseDirectory, name); _log.LogInformation($"Generating MSBuild file {name}"); GenerateMSBuildErrorFile(path); return; } var graph = tfmGraphs[0]; var pathResolver = new DefaultPackagePathResolver(repository.RepositoryRoot); var targets = new List <string>(); var props = new List <string>(); foreach (var library in graph.Flattened.Distinct().OrderBy(g => g.Data.Match.Library)) { var package = repository.FindPackagesById(library.Key.Name).FirstOrDefault(p => p.Version == library.Key.Version); if (package != null) { var criteria = graph.Conventions.Criteria.ForFramework(graph.Framework); var contentItemCollection = new ContentItemCollection(); using (var nupkgStream = File.OpenRead(package.ZipPath)) { var reader = new PackageReader(nupkgStream); contentItemCollection.Load(reader.GetFiles()); } // Find MSBuild thingies var buildItems = contentItemCollection.FindBestItemGroup(criteria, graph.Conventions.Patterns.MSBuildFiles); if (buildItems != null) { // We need to additionally filter to items that are named "{packageId}.targets" and "{packageId}.props" // Filter by file name here and we'll filter by extension when we add things to the lists. var items = buildItems.Items .Where(item => Path.GetFileNameWithoutExtension(item.Path).Equals(package.Id, StringComparison.OrdinalIgnoreCase)) .ToList(); targets.AddRange(items .Select(c => c.Path) .Where(path => Path.GetExtension(path).Equals(".targets", StringComparison.OrdinalIgnoreCase)) .Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar)))); props.AddRange(items .Select(c => c.Path) .Where(path => Path.GetExtension(path).Equals(".props", StringComparison.OrdinalIgnoreCase)) .Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar)))); } } } // Generate the files as needed var targetsName = $"{project.Name}.nuget.targets"; var propsName = $"{project.Name}.nuget.props"; var targetsPath = Path.Combine(project.BaseDirectory, targetsName); var propsPath = Path.Combine(project.BaseDirectory, propsName); if (targets.Any()) { _log.LogInformation($"Generating MSBuild file {targetsName}"); GenerateImportsFile(repository, targetsPath, targets); } else if (File.Exists(targetsPath)) { File.Delete(targetsPath); } if (props.Any()) { _log.LogInformation($"Generating MSBuild file {propsName}"); GenerateImportsFile(repository, propsPath, props); } else if (File.Exists(propsPath)) { File.Delete(propsPath); } }
internal USoundWave(PackageReader reader, Stream ubulk, long ubulkOffset) : base(reader) { Serialize(reader, ubulk, ubulkOffset); }
// Binary serialization, tagged property serialization otherwise // https://github.com/EpicGames/UnrealEngine/blob/7d9919ac7bfd80b7483012eab342cb427d60e8c9/Engine/Source/Runtime/CoreUObject/Private/UObject/Class.cpp#L2146 internal UScriptStruct(PackageReader reader, FName structName) : this(reader, structName.String) { }
private void SaveSavegameDatabase() { var packageReader = new PackageReader(storyFilePath.Text); Package package = packageReader.Read(); AbstractFileInfo globalsLsf = package.Files.FirstOrDefault(p => p.Name == "globals.lsf"); if (globalsLsf == null) { MessageBox.Show("The specified package is not a valid savegame (globals.lsf not found)", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } // Load globals.lsf Resource resource; Stream rsrcStream = globalsLsf.MakeStream(); try { using (var rsrcReader = new LSFReader(rsrcStream)) { resource = rsrcReader.Read(); } } finally { globalsLsf.ReleaseStream(); } // Save story resource and pack into the Story.Story attribute in globals.lsf using (var storyStream = new MemoryStream()) { var storyWriter = new StoryWriter(); storyWriter.Write(storyStream, _story); LSLib.LS.Node storyNode = resource.Regions["Story"].Children["Story"][0]; storyNode.Attributes["Story"].Value = storyStream.ToArray(); } // Save globals.lsf var rewrittenStream = new MemoryStream(); FileVersion version; if (OriginalSavePakVersion == PackageVersion.V15) { version = FileVersion.VerBG3; } else { version = FileVersion.VerExtendedNodes; } var rsrcWriter = new LSFWriter(rewrittenStream, version); rsrcWriter.Write(resource); rewrittenStream.Seek(0, SeekOrigin.Begin); // Re-package global.lsf var rewrittenPackage = new Package(); StreamFileInfo globalsRepacked = StreamFileInfo.CreateFromStream(rewrittenStream, "globals.lsf"); rewrittenPackage.Files.Add(globalsRepacked); List <AbstractFileInfo> files = package.Files.Where(x => x.Name != "globals.lsf").ToList(); rewrittenPackage.Files.AddRange(files); using (var packageWriter = new PackageWriter(rewrittenPackage, $"{storyFilePath.Text}.tmp")) { packageWriter.Version = OriginalSavePakVersion; packageWriter.Compression = CompressionMethod.Zlib; packageWriter.CompressionLevel = CompressionLevel.DefaultCompression; packageWriter.Write(); } rewrittenStream.Dispose(); packageReader.Dispose(); // Create a backup of the original .lsf string backupPath = $"{storyFilePath.Text}.backup"; if (!File.Exists(backupPath)) { File.Move(storyFilePath.Text, backupPath); } else { File.Delete(storyFilePath.Text); } // Replace original savegame with new one File.Move($"{storyFilePath.Text}.tmp", storyFilePath.Text); }
internal FFrameNumber(PackageReader reader) { Value = reader.ReadFloat(); }
internal FPackageIndex(PackageReader reader) { Index = reader.ReadInt32(); Reader = reader; }
internal TMovieSceneEvaluationTree(PackageReader reader) { BaseTree = new FMovieSceneEvaluationTree(reader); Data = new TEvaluationTreeEntryContainer <T>(reader); }
public UObject(PackageReader reader, long maxSize) : this(reader, maxSize, false) { }
private void InstallSitecorePackage([NotNull] string fileName) { Context.SetActiveSite("shell"); using (new SecurityDisabler()) { using (new ProxyDisabler()) { using (new SyncOperationContext()) { var context = new SimpleProcessingContext(); var defaultItemInstallerEvents = new DefaultItemInstallerEvents(new BehaviourOptions(InstallMode.Overwrite, MergeMode.Clear)); context.AddAspect(defaultItemInstallerEvents); var defaultFileInstallerEvents = new DefaultFileInstallerEvents(true); context.AddAspect(defaultFileInstallerEvents); var installer = new Installer(); installer.InstallPackage(FileUtil.MapPath(fileName), context); var packageReader = new PackageReader(FileUtil.MapPath(fileName)); var previewContext = Installer.CreatePreviewContext(); var view = new MetadataView(previewContext); var sink = new MetadataSink(view); sink.Initialize(previewContext); packageReader.Populate(sink); installer.ExecutePostStep(view.PostStep, previewContext); } } } }
internal StrProperty(PackageReader reader, FPropertyTag tag) { Value = reader.ReadFString(); }
internal static void DeleteFiles(IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem, ZipArchive zipArchive, IEnumerable <string> otherPackagesPath, FrameworkSpecificGroup frameworkSpecificGroup, IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers) { var packageTargetFramework = frameworkSpecificGroup.TargetFramework; IPackageFileTransformer transformer; var directoryLookup = frameworkSpecificGroup.Items.ToLookup( p => Path.GetDirectoryName(ResolveTargetPath(msBuildNuGetProjectSystem, fileTransformers, fte => fte.UninstallExtension, GetEffectivePathForContentFile(packageTargetFramework, p), out transformer))); // Get all directories that this package may have added var directories = from grouping in directoryLookup from directory in FileSystemUtility.GetDirectories(grouping.Key, altDirectorySeparator: false) orderby directory.Length descending select directory; // Remove files from every directory foreach (var directory in directories) { var directoryFiles = directoryLookup.Contains(directory) ? directoryLookup[directory] : Enumerable.Empty <string>(); if (!Directory.Exists(Path.Combine(msBuildNuGetProjectSystem.ProjectFullPath, directory))) { continue; } try { foreach (var file in directoryFiles) { if (IsEmptyFolder(file)) { continue; } // Resolve the path string path = ResolveTargetPath(msBuildNuGetProjectSystem, fileTransformers, fte => fte.UninstallExtension, GetEffectivePathForContentFile(packageTargetFramework, file), out transformer); if (msBuildNuGetProjectSystem.IsSupportedFile(path)) { if (transformer != null) { // TODO: use the framework from packages.config instead of the current framework // which may have changed during re-targeting NuGetFramework projectFramework = msBuildNuGetProjectSystem.TargetFramework; List <InternalZipFileInfo> matchingFiles = new List <InternalZipFileInfo>(); foreach (var otherPackagePath in otherPackagesPath) { using (var otherPackageStream = File.OpenRead(otherPackagePath)) { var otherPackageZipArchive = new ZipArchive(otherPackageStream); var otherPackageZipReader = new PackageReader(otherPackageZipArchive); // use the project framework to find the group that would have been installed var mostCompatibleContentFilesGroup = GetMostCompatibleGroup(projectFramework, otherPackageZipReader.GetContentItems(), altDirSeparator: true); if (mostCompatibleContentFilesGroup != null && IsValid(mostCompatibleContentFilesGroup)) { foreach (var otherPackageItem in mostCompatibleContentFilesGroup.Items) { if (GetEffectivePathForContentFile(packageTargetFramework, otherPackageItem) .Equals(GetEffectivePathForContentFile(packageTargetFramework, file), StringComparison.OrdinalIgnoreCase)) { matchingFiles.Add(new InternalZipFileInfo(otherPackagePath, otherPackageItem)); } } } } } try { var zipArchiveFileEntry = zipArchive.GetEntry(PathUtility.ReplaceDirSeparatorWithAltDirSeparator(file)); if (zipArchiveFileEntry != null) { transformer.RevertFile(zipArchiveFileEntry, path, matchingFiles, msBuildNuGetProjectSystem); } } catch (Exception e) { msBuildNuGetProjectSystem.NuGetProjectContext.Log(MessageLevel.Warning, e.Message); } } else { var zipArchiveFileEntry = zipArchive.GetEntry(PathUtility.ReplaceDirSeparatorWithAltDirSeparator(file)); if (zipArchiveFileEntry != null) { DeleteFileSafe(path, zipArchiveFileEntry.Open, msBuildNuGetProjectSystem); } } } } // If the directory is empty then delete it if (!GetFilesSafe(msBuildNuGetProjectSystem, directory).Any() && !GetDirectoriesSafe(msBuildNuGetProjectSystem, directory).Any()) { DeleteDirectorySafe(msBuildNuGetProjectSystem, directory, recursive: false); } } finally { } } }
public void PackageReader_MinClientVersion(string minClientVersion, string expected) { var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackageMinClient(minClientVersion)); using (PackageReader reader = new PackageReader(zip)) { var version = reader.GetMinClientVersion(); Assert.Equal(expected, version.ToNormalizedString()); } }
internal DoubleProperty(PackageReader reader) { Position = reader.Position; Value = reader.ReadDouble(); }
public void PackageReader_ContentWithFrameworks() { var zip = TestPackages.GetZip(TestPackages.GetLegacyContentPackageWithFrameworks()); using (PackageReader reader = new PackageReader(zip)) { var groups = reader.GetContentItems().ToArray(); Assert.Equal(3, groups.Count()); } }
protected override void ProcessRecord() { var fileName = Path; PerformInstallAction(() => { if (!System.IO.Path.IsPathRooted(fileName)) { var packagePath = FullPackagePath(fileName); WriteVerbose($"Path is not rooted. Updating to {packagePath}."); if (!FileUtil.Exists(packagePath)) { packagePath = System.IO.Path.GetFullPath( System.IO.Path.Combine( CurrentProviderLocation("FileSystem").ProviderPath, fileName)); WriteVerbose($"Path could not be found. Updating to {packagePath}."); if (!FileUtil.Exists(packagePath)) { WriteVerbose("Path still could not be found. Check that the file actually exists in the Sitecore package directory."); } } fileName = packagePath; } if (ShouldProcess(fileName, "Install package")) { var indexSetting = Sitecore.Configuration.Settings.Indexing.Enabled; if (DisableIndexing.IsPresent) { Sitecore.Configuration.Settings.Indexing.Enabled = false; } try { IProcessingContext context = new SimpleProcessingContext(); IItemInstallerEvents instance1 = new DefaultItemInstallerEvents(new BehaviourOptions(InstallMode, MergeMode)); context.AddAspect(instance1); IFileInstallerEvents instance2 = new DefaultFileInstallerEvents(true); context.AddAspect(instance2); var installer = new Installer(); installer.InstallPackage(fileName, context); ISource<PackageEntry> source = new PackageReader(fileName); var previewContext = Installer.CreatePreviewContext(); var view = new MetadataView(previewContext); var metadataSink = new MetadataSink(view); metadataSink.Initialize(previewContext); source.Populate(metadataSink); installer.ExecutePostStep(view.PostStep, previewContext); } finally { if (DisableIndexing.IsPresent) { Sitecore.Configuration.Settings.Indexing.Enabled = indexSetting; } } } }); }
public void PackageReader_NoReferences() { var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackage()); using (PackageReader reader = new PackageReader(zip)) { var groups = reader.GetReferenceItems().ToArray(); Assert.Equal(3, groups.Count()); Assert.Equal(4, groups.SelectMany(e => e.Items).Count()); } }
public void PackageReader_EmptyLibFolder() { var zip = TestPackages.GetZip(TestPackages.GetLibEmptyFolderPackage()); using (PackageReader reader = new PackageReader(zip)) { var groups = reader.GetReferenceItems().ToArray(); var emptyGroup = groups.Where(g => g.TargetFramework == NuGetFramework.ParseFolder("net45")).Single(); Assert.Equal(0, emptyGroup.Items.Count()); } }
public void PackageReader_SupportedFrameworks() { var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackage()); using (PackageReader reader = new PackageReader(zip)) { string[] frameworks = reader.GetSupportedFrameworks().Select(f => f.DotNetFrameworkName).ToArray(); Assert.Equal("Any,Version=v0.0", frameworks[0]); Assert.Equal(".NETFramework,Version=v4.0", frameworks[1]); Assert.Equal(".NETFramework,Version=v4.5", frameworks[2]); Assert.Equal(3, frameworks.Length); } }
internal static void DeserializeMeshFilter(Package package, MeshFilter meshFilter, PackageReader reader) { string checksum = reader.ReadString(); Mesh mesh; if (Sharing.instance.shareMeshes && Sharing.instance.meshes.TryGetValue(checksum, out mesh)) { Sharing.instance.meshit++; } else { mesh = PackageManager.FindAssetByChecksum(checksum).Instantiate <Mesh>(); Sharing.instance.meshes[checksum] = mesh; Sharing.instance.mesload++; } meshFilter.sharedMesh = mesh; }
/// <summary> /// Deploys an update to an existing model from a specified package. /// </summary> /// <param name="packageFile">File name of the input package.</param> /// <param name="versionName">Name of the version of master data to update.</param> private static void DeployUpdate(string packageFile, string versionName) { Console.WriteLine("Deploying package {0}, updating version {1} of the master data", packageFile, versionName); ModelDeployer deployer = new ModelDeployer(); ModelReader reader = new ModelReader(); // Deploy it. Warnings errorsAsWarnings = null; using (var package = new PackageReader(packageFile)) { // Get the ID for the model named in the package var firstPackage = package.FirstOrDefault(); if (firstPackage != null) { Identifier modelId = GetModelIdentifier(reader, firstPackage.ModelId.Name); // Now get the version Id for that model and the given version name. reader.ModelId = modelId; } Identifier versionId = GetVersionIdentifier(reader, versionName); errorsAsWarnings = deployer.DeployUpdate(package.GetEnumerator(), true, versionId); } Console.WriteLine("Package was deployed with {0} warnings", errorsAsWarnings.Count); }
public static bool RenameSave(string pathToSave, string newName) { try { string baseOldName = Path.GetFileNameWithoutExtension(pathToSave); string baseNewName = Path.GetFileNameWithoutExtension(newName); string output = Path.ChangeExtension(Path.Combine(Path.GetDirectoryName(pathToSave), newName), ".lsv"); using (var reader = new PackageReader(pathToSave)) { Package package = reader.Read(); AbstractFileInfo saveScreenshotImage = package.Files.FirstOrDefault(p => p.Name.EndsWith(".png")); if (saveScreenshotImage != null) { saveScreenshotImage.Name = saveScreenshotImage.Name.Replace(Path.GetFileNameWithoutExtension(saveScreenshotImage.Name), baseNewName); DivinityApp.Log($"Renamed internal screenshot '{saveScreenshotImage.Name}' in '{output}'."); } // Edit the saved date in the meta.lsf to avoid "corruption" messages /* * AbstractFileInfo metaFile = package.Files.FirstOrDefault(p => p.Name == "meta.lsf"); * if (metaFile != null) * { * Resource resource; * System.IO.MemoryStream ms = null; * System.IO.Stream rsrcStream = null; * try * { * rsrcStream = metaFile.MakeStream(); * using (var rsrcReader = new LSFReader(rsrcStream)) * { * resource = rsrcReader.Read(); * * if (resource != null) * { * var saveTimeNode = resource.FindNode("SaveTime"); * * if (saveTimeNode != null) * { * NodeAttribute yearAtt = null; * NodeAttribute monthAtt = null; * NodeAttribute dayAtt = null; * NodeAttribute hoursAtt = null; * NodeAttribute minutesAtt = null; * NodeAttribute secondsAtt = null; * NodeAttribute millisecondsAtt = null; * * saveTimeNode.Attributes.TryGetValue("Year", out yearAtt); * saveTimeNode.Attributes.TryGetValue("Month", out monthAtt); * saveTimeNode.Attributes.TryGetValue("Day", out dayAtt); * saveTimeNode.Attributes.TryGetValue("Hours", out hoursAtt); * saveTimeNode.Attributes.TryGetValue("Minutes", out minutesAtt); * saveTimeNode.Attributes.TryGetValue("Seconds", out secondsAtt); * saveTimeNode.Attributes.TryGetValue("Milliseconds", out millisecondsAtt); * * var time = DateTime.Now; * * DivinityApp.LogMessage($"Year: {yearAtt.Type}"); * DivinityApp.LogMessage($"Month: {monthAtt.Type}"); * DivinityApp.LogMessage($"Day: {dayAtt.Type}"); * DivinityApp.LogMessage($"Hours: {hoursAtt.Type}"); * DivinityApp.LogMessage($"Minutes: {minutesAtt.Type}"); * DivinityApp.LogMessage($"Seconds: {secondsAtt.Type}"); * DivinityApp.LogMessage($"Milliseconds: {millisecondsAtt.Type}"); * * yearAtt.Value = (Byte)time.Year; * monthAtt.Value = (Byte)time.Month; * dayAtt.Value = (Byte)time.Day; * hoursAtt.Value = (Byte)time.Hour; * minutesAtt.Value = (Byte)time.Minute; * secondsAtt.Value = (Byte)time.Second; * millisecondsAtt.Value = (UInt16)time.Millisecond; * * DivinityApp.LogMessage($"Updated SaveTime in save's meta.lsf."); * } * else * { * DivinityApp.LogMessage($"Couldn't find SaveTime node '{String.Join(";", resource.Regions.Values.First().Children.Keys)}'."); * } * * ms = new System.IO.MemoryStream(new byte[4096], true); * var rscrWriter = new LSFWriter(ms, FileVersion.CurrentVersion); * rscrWriter.Write(resource); * ms.Position = 0; * var data = ms.ToArray(); * * if (!ms.CanRead) DivinityApp.LogMessage("MemoryStream is not readable!"); * if(!ms.CanWrite) DivinityApp.LogMessage("MemoryStream is not writable!"); * if(!rsrcStream.CanRead) DivinityApp.LogMessage("rsrcStream is not readable!"); * if(!rsrcStream.CanWrite) DivinityApp.LogMessage("rsrcStream is not writable!"); * * rsrcStream.Write(data, 0, data.Length); * ms.Close(); * } * } * } * finally * { * if (metaFile != null) metaFile.ReleaseStream(); * if (ms != null) ms.Dispose(); * if (rsrcStream != null) rsrcStream.Dispose(); * } * } */ using (var writer = new PackageWriter(package, output)) { writer.Version = Package.CurrentVersion; writer.Compression = LSLib.LS.Enums.CompressionMethod.Zlib; writer.CompressionLevel = CompressionLevel.DefaultCompression; writer.Write(); } File.SetLastWriteTime(output, File.GetLastWriteTime(pathToSave)); File.SetLastAccessTime(output, File.GetLastAccessTime(pathToSave)); return(true); } } catch (Exception ex) { DivinityApp.Log($"Failed to rename save: {ex}"); } return(false); }
internal FloatProperty(PackageReader reader, FPropertyTag tag) { Value = reader.ReadFloat(); }
internal static void DeserializeMeshRenderer(Package package, MeshRenderer renderer, PackageReader reader) { int count = reader.ReadInt32(); Material[] materials = new Material[count]; for (int i = 0; i < count; i++) { string checksum = reader.ReadString(); Material material; if (!Sharing.instance.materials.TryGetValue(checksum, out material)) { material = PackageManager.FindAssetByChecksum(checksum).Instantiate <Material>(); Sharing.instance.materials[checksum] = material; Sharing.instance.matload++; } else { Sharing.instance.mathit++; } materials[i] = material; } renderer.sharedMaterials = materials; }
internal Int16Property(PackageReader reader) { Position = reader.Position; Value = reader.ReadInt16(); }
internal FPackageIndex(PackageReader reader, int index) { Index = index; Reader = reader; }
/// <summary> /// Deploys a copy of a model from a package, with a new name. /// </summary> /// <param name="packageFile">File name of the input package.</param> /// <param name="modelName">New name for the model being deployed.</param> private static void DeployNew(string packageFile, string modelName) { Console.WriteLine("Deploying package {0} using new model name {1}", packageFile, modelName); ModelDeployer deployer = new ModelDeployer(); // Deploy the package. Warnings errorsAsWarnings = null; using (var package = new PackageReader(packageFile)) { Identifier newId = null; errorsAsWarnings = deployer.DeployNew(package.GetEnumerator(), modelName, out newId); } Console.WriteLine("Package was deployed with {0} warnings", errorsAsWarnings.Count); }
internal FLevelSequenceLegacyObjectReference(PackageReader reader) { ObjectId = new FUniqueObjectGuid(reader); ObjectPath = reader.ReadFString(); }
internal UInt32Property(PackageReader reader, FPropertyTag tag) { Position = reader.Position; Value = reader.ReadUInt32(); }
internal Transform(PackageReader reader) { SourceText = new FText(reader); TransformType = (ETransformType)reader.ReadByte(); }
internal ObjectProperty(PackageReader reader, FPropertyTag tag) { Value = new FPackageIndex(reader); }
internal TextProperty(PackageReader reader, FPropertyTag tag) { Value = new FText(reader); }