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;
}
