public ArmletStorage() { _storageBase = new StorageBase<AStoredData>("armlet"); var readJson = _storageBase.ReadFile(StorageBase<AStoredData>.DefaultDir()); if (readJson != null) { _savedData = JsonConvert.DeserializeObject<List<AStoredData>>(readJson) .ToDictionary(a => a.Id); } else { _savedData = new Dictionary<byte, AStoredData>(); } }
private string GetStorageValue(StorageBase storage) { if (storage == null) { return(null); } string value = string.Empty; foreach (short digit in storage.Data) { if (digit != 1 && digit != 0) { throw new Exception("Bad binary digit."); } value += digit == 1 ? "1" : "0"; } return(value); }
private StorageBase GetStorageForOperand(Operand operand) { if (!operand.IsInitialized) { return(null); } StorageBase storage = null; if (operand.IsAddress) { storage = Data[Convert.ToInt32(operand.Value, 6)]; } else if (operand.IsRegister) { storage = m_registers[operand.Value]; } return(storage); }
private void LoadItems() { bases = new List <StorageBase>(); points = new List <PointOfPurchase>(); StorageBase base1 = new StorageBase("Base1"); base1.AddItem(new StockItem("Phone", "0001", 45, 10)); bases.Add(base1); StorageBase base2 = new StorageBase("Base2"); base2.AddItem(new StockItem("Car", "0002", 45, 10)); base2.AddItem(new StockItem("Plane", "0003", 56, 4)); base2.AddItem(new StockItem("Bottle", "0004", 13, 150)); bases.Add(base2); LoadItemsComboBox(); }
public GoogleSearcher(string searchQuery, StorageBase cache) : base(cache) { InitActionsToDo(searchQuery); }
public static void StorageBase_RequestStorageSaveGameData_Prefix(StorageBase __instance) { _savingStorage = true; }
/// <summary> /// Convert between base 1024 storage units [TB, GB, MB, KB, Byte] /// </summary> /// <param name="SizeDifferential">Storage conversion differential [enum]</param> /// <param name="UnitSize">Size as mutiple of unit type units [double]</param> /// <param name="BaseUnit">Size of the base power [enum]</param> /// <returns>Converted unit size [double]</returns> public static double Convert(Differential SizeDifferential, double UnitSize, StorageBase BaseUnit = StorageBase.BASE10) { if (UnitSize < 0.000000000001) { return(0); } double POWER1 = 1000; double POWER2 = 1000000; double POWER3 = 1000000000; double POWER4 = 1000000000000; if (BaseUnit == StorageBase.BASE2) { POWER1 = 1024; POWER2 = 1048576; POWER3 = 1073741824; POWER4 = 1099511627776; } switch (SizeDifferential) { case Differential.ByteToKilo: return(UnitSize / POWER1); case Differential.ByteToMega: return(UnitSize / POWER2); case Differential.ByteToGiga: return(UnitSize / POWER3); case Differential.ByteToTera: return(UnitSize / POWER4); case Differential.KiloToByte: return(UnitSize * POWER1); case Differential.KiloToMega: return(UnitSize / POWER1); case Differential.KiloToGiga: return(UnitSize / POWER2); case Differential.KiloToTera: return(UnitSize / POWER3); case Differential.MegaToByte: return(UnitSize * POWER2); case Differential.MegaToKilo: return(UnitSize * POWER1); case Differential.MegaToGiga: return(UnitSize / POWER1); case Differential.MegaToTera: return(UnitSize / POWER2); case Differential.GigaToByte: return(UnitSize * POWER3); case Differential.GigaToKilo: return(UnitSize * POWER2); case Differential.GigaToMega: return(UnitSize * POWER1); case Differential.GigaToTerra: return(UnitSize / POWER1); case Differential.TeraToByte: return(UnitSize * POWER4); case Differential.TeraToKilo: return(UnitSize * POWER3); case Differential.TeraToMega: return(UnitSize * POWER2); case Differential.TeraToGiga: return(UnitSize * POWER1); } return(0); }
/* * /// <summary> * /// Adds an asset from a file in a bank * /// </summary> * /// <param name="bankname">Bank's name</param> * /// <param name="assetname">Asset name in the bank</param> * /// <param name="filename">File to add in the bank</param> * /// <returns>True on success</returns> * static public bool SaveAsset(string bankname, string assetname, string filename) * { * if (string.IsNullOrEmpty(bankname) || string.IsNullOrEmpty(assetname) || string.IsNullOrEmpty(filename)) * return false; * * using (Stream stream = new FileStream(filename, FileMode.Open)) * return SaveAsset(bankname, assetname, stream); * } * * * /// <summary> * /// Adds an asset from a stream in a bank * /// </summary> * /// <param name="bankname">Bank's name</param> * /// <param name="assetname">Asset name in the bank</param> * /// <param name="stream">Stream to add in the bank</param> * /// <returns>True on success</returns> * static public bool SaveAsset(string bankname, string assetname, Stream stream) * { * if (string.IsNullOrEmpty(bankname) || string.IsNullOrEmpty(assetname) || stream == null) * return false; * * Trace.Write("Saving asset \"{0}\" to bank \"{1}\"... ", assetname, bankname); * * try * { * // Open bank * ZipStorer zip = ZipStorer.Open(bankname, FileAccess.Write); * * // Get a listing of all present files * List<ZipStorer.ZipFileEntry> dir = zip.ReadCentralDir(); * * // Remove duplicate name before insert * List<ZipStorer.ZipFileEntry> remove = new List<ZipStorer.ZipFileEntry>(); * foreach (ZipStorer.ZipFileEntry ent in dir) * { * if (ent.FilenameInZip == assetname) * remove.Add(ent); * } * ZipStorer.RemoveEntries(ref zip, remove); * * * // Add stream * zip.AddStream(ZipStorer.Compression.Deflate, assetname, stream, DateTime.Now, string.Empty); * * * // Close the file * zip.Close(); * * Trace.WriteLine("Done !"); * } * catch (Exception e) * { * Trace.WriteLine("Failed !"); * Trace.WriteLine(e.Message); * Trace.WriteLine(e.StackTrace); * } * * * return true; * } * */ /// <summary> /// Saves all assets to a storage /// </summary> /// <param name="storage">Storage bank</param> /// <returns>True on success</returns> static public bool SaveAssetsToStorage(StorageBase storage) { if (storage == null) { return(false); } Trace.WriteLine("[ResourceManager] : Saving all resources to storage \"" + storage.ToString() + "\"..."); try { // Xml settings XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.OmitXmlDeclaration = false; settings.IndentChars = "\t"; settings.Encoding = ASCIIEncoding.ASCII; // for each registred asset foreach (RegisteredAsset ra in RegisteredAssets) { // No asset if (ra.Count == 0) { continue; } // Save to storage using (Stream stream = storage.CreateFile(string.Format("{0}.xml", ra.Type.Name))) { if (stream == null) { continue; } // Create Xml document from storage stream using (XmlWriter doc = XmlWriter.Create(stream, settings)) { doc.WriteStartDocument(true); doc.WriteStartElement("bank"); ra.Save(doc); // Close xml doc.WriteEndElement(); doc.WriteEndDocument(); doc.Flush(); } } } storage.Flush(); return(true); } catch (Exception e) { Trace.WriteLine(e.Message); Trace.WriteLine(e.StackTrace); } return(false); }
public DefaultAppInsightsClientWrapper(string instrumentationKey, StorageBase storage, IProcessLockFactory processLockFactory) : base(instrumentationKey) { this.storage = storage; this.processLockFactory = processLockFactory; }
public Node(T d, StorageBase sb) { Data = d; this.sb = sb; }
/// <summary> /// Loads settings from an xml document /// </summary> /// <returns>The options</returns> /// <exception cref="OptionsException">Any problems during loading</exception> public static ProgramOptions LoadSettings() { ProgramOptions options = new ProgramOptions(); try { if (File.Exists(Files.ProfileFile)) { XmlDocument document = new XmlDocument(); document.Load(Files.ProfileFile); options.AmountOf7ZipProcessesToProcessSynchronously = readNode(document, "/Settings/Core/Performance/AmountOf7ZipProcessesToProcessSynchronously", Constants.AmountOf7ZipProcessesToProcessSynchronouslyMinimum, Constants.AmountOf7ZipProcessesToProcessSynchronouslyMaximum, Constants.AmountOf7ZipProcessesToProcessSynchronouslyDefault); options.AmountOfStoragesToProcessSynchronously = readNode(document, "/Settings/Core/Performance/AmountOfStoragesToProcessSynchronously", Constants.AmountOfStoragesToProcessSynchronouslyMinimum, Constants.AmountOfStoragesToProcessSynchronouslyMaximum, Constants.AmountOfStoragesToProcessSynchronouslyDefault); string priority = readNode(document, "/Settings/Core/Performance/ProcessingPriority", ThreadPriority.BelowNormal.ToString()); options.Priority = (ThreadPriority)ThreadPriorityLevel.Parse(typeof(ThreadPriority), priority); options.DontCareAboutPasswordLength = readNode(document, "/Settings/Core/Security/DontCareAboutPasswordLength", false); string logLevel = readNode(document, "/Settings/Core/Logging/Level", LogLevel.Normal.ToString()); options.LoggingLevel = (LogLevel)ThreadPriorityLevel.Parse(typeof(LogLevel), logLevel); options.LogsFolder = readNode(document, "/Settings/Core/Logging/Location", Directories.LogsFolder); options.ShowSchedulerInTray = readNode(document, "/Settings/Core/ScheduleApplication/ShowInTray", true); options.PuttingOffBackupCpuLoading = (byte)readNode(document, "/Settings/Core/ScheduleApplication/PuttingOffBackupCpuLoading", Constants.MinimumCpuLoading, Constants.MaximumCpuLoading, Constants.DefaultCpuLoading); options.DontNeedScheduler = readNode(document, "/Settings/Core/ScheduleApplication/" + _DONT_NEED_SCHEDULER_TAG, false); options.HaveNoNetworkAndInternet = readNode(document, "/Settings/Core/" + _CONFIGURATOR_TAG + "/" + _HAVE_NO_INTERNET_AND_NETWORK_TAG, false); options.DontCareAboutSchedulerStartup = readNode(document, "/Settings/Core/" + _CONFIGURATOR_TAG + "/" + _DONT_CARE_ABOUT_SCHEDULER_STARTUP_TAG, false); options.HideAboutTab = readNode(document, "/Settings/Core/" + _CONFIGURATOR_TAG + "/" + _HIDE_ABOUT_TAB_TAG, false); XmlNodeList taskNodes = document.SelectNodes("/Settings/BackupTasks/Task"); foreach (XmlNode taskNode in taskNodes) { BackupTask task = new BackupTask(); task.Name = taskNode.Attributes[_NAME].Value; task.SecretPassword = taskNode[_PASSWORD].InnerText; XmlNodeList compressionItemsNodes = taskNode[_WHAT_TAG].ChildNodes; XmlNodeList storagesNodes = taskNode[_WHERE_TAG].ChildNodes; XmlNodeList beforeNodes = taskNode[_CHAIN_OF_PROGRAMS_TO_RUN][_BEFORE_BACKUP].ChildNodes; XmlNodeList afterNodes = taskNode[_CHAIN_OF_PROGRAMS_TO_RUN][_AFTER_BACKUP].ChildNodes; foreach (XmlNode nodeItem in beforeNodes) { BackupEventTaskInfo info = new BackupEventTaskInfo( nodeItem.Attributes[_NAME].Value, nodeItem.Attributes[_ARGUMENTS].Value); task.BeforeBackupTasksChain.Add(info); } foreach (XmlNode nodeItem in afterNodes) { BackupEventTaskInfo info = new BackupEventTaskInfo( nodeItem.Attributes[_NAME].Value, nodeItem.Attributes[_ARGUMENTS].Value); task.AfterBackupTasksChain.Add(info); } foreach (XmlNode compressionItemNode in compressionItemsNodes) { CompressionItem item = new CompressionItem( compressionItemNode.Attributes[_TARGET_TAG].Value, bool.Parse(compressionItemNode.Attributes[_IS_FOLDER].Value), (CompressionDegree)CompressionDegree.Parse(typeof(CompressionDegree), compressionItemNode.Attributes[_COMPRESSION_DEGREE_TAG].Value)); task.FilesFoldersList.Add(item); } XmlNode schedule = taskNode[_SCHEDULE_TAG]; XmlNode zeroHour = schedule[_TIME_TAG]; XmlNode days = schedule[_DAYS_TAG]; task.Hours = byte.Parse(zeroHour.Attributes[_HOUR_TAG].Value); task.Minutes = byte.Parse(zeroHour.Attributes[_MINUTE_TAG].Value); foreach (DayOfWeek enumItem in DayOfWeek.GetValues(typeof(DayOfWeek))) { task.SetSchedulingStateOfDay(enumItem, bool.Parse(days.Attributes[enumItem.ToString()].Value)); } foreach (XmlNode storageNode in storagesNodes) { Dictionary <string, string> settings = new Dictionary <string, string>(); foreach (XmlNode node in storageNode.ChildNodes) { settings.Add(node.Name, node.InnerText); } XmlAttribute assemblyAttribute = storageNode.Attributes[_ASSEMBLY_TAG]; // this is done to prevent using different assemblies of a different copies of a program Assembly assembly = (assemblyAttribute != null) ? Assembly.LoadFrom(assemblyAttribute.Value) : Assembly.GetExecutingAssembly(); string type = storageNode.Attributes[_TYPE_TAG].Value; StorageBase storage = (StorageBase)Activator.CreateInstance(assembly.GetType(type), settings); task.Storages.Add(storage); } options.BackupTasks.Add(task.Name, task); } } } catch (Exception exc) { Debug.WriteLine(exc.ToString()); throw new OptionsException( string.Format(CultureInfo.CurrentCulture, _fileInaccessibleOrCorrupted, Files.ProfileFile, exc.Message)); } return(options); }
public ProjectClient(StorageBase storage) { _storage = storage ?? throw new ArgumentNullException(nameof(storage)); }
/// <summary> /// Save the texture as a PNG image in the bank /// </summary> /// <param name="storage">Bank's name</param> /// <param name="assetname">Asset name in the bank</param> /// <returns>True on success</returns> public bool SaveToBank(StorageBase storage, string assetname) { return(base.SaveToStorage(TextureTarget.Texture2D, storage, assetname)); }
public void Init(StorageBase sb, string key) { this.sb = sb; this.key = key; OnInit(); }
public AsimovAppInsightsClientWrapper(bool isUtcEnabled, string instrumentationKey, TelemetrySession hostTelemetrySession, StorageBase storage, IProcessLockFactory processLockFactory) : base(instrumentationKey) { this.isUtcEnabled = isUtcEnabled; this.hostTelemetrySession = hostTelemetrySession; this.storage = storage; this.processLockFactory = processLockFactory; }
internal SenderUnderTest(StorageBase storage, PersistenceTransmitter transmitter) : base(storage, transmitter, startSending: false) { }
/// <summary> /// Constructor /// </summary> /// <param name="storage">Name of the bank</param> public ImportGIFForm(StorageBase storage) { InitializeComponent(); }
public CopyingToStorageNotificationEventArgs(StorageBase storage, ProcessingState state) : base() { _storage = storage; _state = state; }