388 lines
17 KiB
C#
388 lines
17 KiB
C#
//------------------------------------------------------------------------------
|
|
// <auto-generated>
|
|
// This code was generated by a tool.
|
|
// Runtime Version:4.0.30319.1
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
// </auto-generated>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace Duplicati.Library.Main.Strings {
|
|
using System;
|
|
|
|
|
|
/// <summary>
|
|
/// A strongly-typed resource class, for looking up localized strings, etc.
|
|
/// </summary>
|
|
// This class was auto-generated by the StronglyTypedResourceBuilder
|
|
// class via a tool like ResGen or Visual Studio.
|
|
// To add or remove a member, edit your .ResX file then rerun ResGen
|
|
// with the /str option, or rebuild your VS project.
|
|
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
|
|
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
|
|
internal class FhOptions {
|
|
|
|
private static global::System.Resources.ResourceManager resourceMan;
|
|
|
|
private static global::System.Globalization.CultureInfo resourceCulture;
|
|
|
|
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
|
|
internal FhOptions() {
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the cached ResourceManager instance used by this class.
|
|
/// </summary>
|
|
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
|
|
internal static global::System.Resources.ResourceManager ResourceManager {
|
|
get {
|
|
if (object.ReferenceEquals(resourceMan, null)) {
|
|
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Duplicati.Library.Main.Strings.FhOptions", typeof(FhOptions).Assembly);
|
|
resourceMan = temp;
|
|
}
|
|
return resourceMan;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overrides the current thread's CurrentUICulture property for all
|
|
/// resource lookups using this strongly typed resource class.
|
|
/// </summary>
|
|
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
|
|
internal static global::System.Globalization.CultureInfo Culture {
|
|
get {
|
|
return resourceCulture;
|
|
}
|
|
set {
|
|
resourceCulture = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to This is a very advanced option! This option can be used to select a block hash algorithm with smaller or larger hash size, for performance or storage space reasons..
|
|
/// </summary>
|
|
internal static string FhblockhashalgorithmLong {
|
|
get {
|
|
return ResourceManager.GetString("FhblockhashalgorithmLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to The hash algorithm used on blocks.
|
|
/// </summary>
|
|
internal static string FhblockhashalgorithmShort {
|
|
get {
|
|
return ResourceManager.GetString("FhblockhashalgorithmShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to A fragment of memory is used to reduce database lookups. You should not change this value unless you get warnings in the log..
|
|
/// </summary>
|
|
internal static string FhblockhashlookupsizeLong {
|
|
get {
|
|
return ResourceManager.GetString("FhblockhashlookupsizeLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Memory used by the block hash.
|
|
/// </summary>
|
|
internal static string FhblockhashlookupsizeShort {
|
|
get {
|
|
return ResourceManager.GetString("FhblockhashlookupsizeShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to The blocksize determines how files are fragmented. Choosing a large value will cause a larger overhead on file changes, choosing a small value will cause a large overhead on storage of file lists. Note that the value cannot be changed after remote files are created..
|
|
/// </summary>
|
|
internal static string FhblocksizeLong {
|
|
get {
|
|
return ResourceManager.GetString("FhblocksizeLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Blocksize used in hashing.
|
|
/// </summary>
|
|
internal static string FhblocksizeShort {
|
|
get {
|
|
return ResourceManager.GetString("FhblocksizeShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to This option can be used to limit the scan to only files that are known to have changed. This is usually only activated in combination with a filesystem watcher that keeps track of file changes..
|
|
/// </summary>
|
|
internal static string FhchangedfilesetLong {
|
|
get {
|
|
return ResourceManager.GetString("FhchangedfilesetLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to List of files to examine for changes.
|
|
/// </summary>
|
|
internal static string FhchangedfilesetShort {
|
|
get {
|
|
return ResourceManager.GetString("FhchangedfilesetShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Path to the file containing the local cache of the remote file database.
|
|
/// </summary>
|
|
internal static string FhdbpathLong {
|
|
get {
|
|
return ResourceManager.GetString("FhdbpathLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Path to the local state database.
|
|
/// </summary>
|
|
internal static string FhdbpathShort {
|
|
get {
|
|
return ResourceManager.GetString("FhdbpathShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to This option can be used to supply a list of deleted files. This option will be ignored unless the option --{0} is also set..
|
|
/// </summary>
|
|
internal static string FhdeletedfilesetLong {
|
|
get {
|
|
return ResourceManager.GetString("FhdeletedfilesetLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to List of deleted files.
|
|
/// </summary>
|
|
internal static string FhdeletedfilesetShort {
|
|
get {
|
|
return ResourceManager.GetString("FhdeletedfilesetShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to This option can be used to experiment with different settings and observe the outcome without changing actual files..
|
|
/// </summary>
|
|
internal static string FhdryrunLong {
|
|
get {
|
|
return ResourceManager.GetString("FhdryrunLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Does not perform any modifications.
|
|
/// </summary>
|
|
internal static string FhdryrunShort {
|
|
get {
|
|
return ResourceManager.GetString("FhdryrunShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to This is a very advanced option! This option can be used to select a file hash algorithm with smaller or larger hash size, for performance or storage space reasons..
|
|
/// </summary>
|
|
internal static string FhfilehashalgorithmLong {
|
|
get {
|
|
return ResourceManager.GetString("FhfilehashalgorithmLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to The hash algorithm used on files.
|
|
/// </summary>
|
|
internal static string FhfilehashalgorithmShort {
|
|
get {
|
|
return ResourceManager.GetString("FhfilehashalgorithmShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to A fragment of memory is used to reduce database lookups. You should not change this value unless you get warnings in the log..
|
|
/// </summary>
|
|
internal static string FhfilehashlookupsizeLong {
|
|
get {
|
|
return ResourceManager.GetString("FhfilehashlookupsizeLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Memory used by the file hash.
|
|
/// </summary>
|
|
internal static string FhfilehashlookupsizeShort {
|
|
get {
|
|
return ResourceManager.GetString("FhfilehashlookupsizeShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to This option can be used to speed up backup operations by keeping scantimes and other path related data in memory.
|
|
/// </summary>
|
|
internal static string FhfilepathlookupsizeLong {
|
|
get {
|
|
return ResourceManager.GetString("FhfilepathlookupsizeLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Memory used to keep paths cached.
|
|
/// </summary>
|
|
internal static string FhfilepathlookupsizeShort {
|
|
get {
|
|
return ResourceManager.GetString("FhfilepathlookupsizeShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to As files are changed, some data stored at the remote destination may not be required. This option controls how much wasted space the destination can contain before being reclaimed. This value cannot be less than the volumesize, the default value is two times the volumesize..
|
|
/// </summary>
|
|
internal static string FhmaxwastesizeLong {
|
|
get {
|
|
return ResourceManager.GetString("FhmaxwastesizeLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to The maximum allowed wasted space.
|
|
/// </summary>
|
|
internal static string FhmaxwastesizeShort {
|
|
get {
|
|
return ResourceManager.GetString("FhmaxwastesizeShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to A fragment of memory is used to reduce database lookups. You should not change this value unless you get warnings in the log..
|
|
/// </summary>
|
|
internal static string FhmetadatahashlookupsizeLong {
|
|
get {
|
|
return ResourceManager.GetString("FhmetadatahashlookupsizeLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Memory used by the metadata hash.
|
|
/// </summary>
|
|
internal static string FhmetadatahashlookupsizeShort {
|
|
get {
|
|
return ResourceManager.GetString("FhmetadatahashlookupsizeShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to If a large number of small files are detected during a backup, or wasted space is found after deleting backups, the remote data will be compacted. Use this option to disable such automatic compacting and only compact when running the compact command..
|
|
/// </summary>
|
|
internal static string FhnoautocompactLong {
|
|
get {
|
|
return ResourceManager.GetString("FhnoautocompactLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Disable automatic compating.
|
|
/// </summary>
|
|
internal static string FhnoautocompactShort {
|
|
get {
|
|
return ResourceManager.GetString("FhnoautocompactShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to If this flag is set, the local database is not compared to the remote filelist on startup. The intended usage for this option is to work correctly in cases where the filelisting is broken or unavailable..
|
|
/// </summary>
|
|
internal static string FhnobackendverificationLong {
|
|
get {
|
|
return ResourceManager.GetString("FhnobackendverificationLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Do not query backend at startup.
|
|
/// </summary>
|
|
internal static string FhnobackendverificationShort {
|
|
get {
|
|
return ResourceManager.GetString("FhnobackendverificationShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to If this flag is set, no index files are uploaded to the remote destination. This reduces the required storage as well as the required transfer, but makes restoring slower as more volumes must be downloaded..
|
|
/// </summary>
|
|
internal static string FhnoindexfilesLong {
|
|
get {
|
|
return ResourceManager.GetString("FhnoindexfilesLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Do not upload index files.
|
|
/// </summary>
|
|
internal static string FhnoindexfilesShort {
|
|
get {
|
|
return ResourceManager.GetString("FhnoindexfilesShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Stores empty metadata, such as file timestamps and attributes. This decreases the required storage space as well as the processing time..
|
|
/// </summary>
|
|
internal static string FhnometadataLong {
|
|
get {
|
|
return ResourceManager.GetString("FhnometadataLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Disable storing file metadata.
|
|
/// </summary>
|
|
internal static string FhnometadataShort {
|
|
get {
|
|
return ResourceManager.GetString("FhnometadataShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Enable this option to look into other files on this machine to find existing blocks. This is a fairly slow operation but can limit the size of downloads..
|
|
/// </summary>
|
|
internal static string FhpatchwithlocalblocksLong {
|
|
get {
|
|
return ResourceManager.GetString("FhpatchwithlocalblocksLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Use local file data when restoring.
|
|
/// </summary>
|
|
internal static string FhpatchwithlocalblocksShort {
|
|
get {
|
|
return ResourceManager.GetString("FhpatchwithlocalblocksShort", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to When examining the size of a volume in consideration for compating, a small tolerance value is used, by default 1 percent of the volume size. This ensures that large volumes which may have a few bytes wasted space are not downloaded and rewritten..
|
|
/// </summary>
|
|
internal static string FhvolumesizetoleranceLong {
|
|
get {
|
|
return ResourceManager.GetString("FhvolumesizetoleranceLong", resourceCulture);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Looks up a localized string similar to Volume size threshold.
|
|
/// </summary>
|
|
internal static string FhvolumesizetoleranceShort {
|
|
get {
|
|
return ResourceManager.GetString("FhvolumesizetoleranceShort", resourceCulture);
|
|
}
|
|
}
|
|
}
|
|
}
|