///<summary>
/// Save's the chart into a binary data
///</summary>
///<param name="serializationType">Type of serialization to use.</param>
/// <returns>true - if file was succesfully saved. false - otherwise</returns>
public byte[] SaveFile(SerializationTypeEnum serializationType)
{
try
{
XElement xRoot;
XDocument xDocument = new XDocument(xRoot = new XElement("StockChartX", new XAttribute("SaveType", serializationType)));
ConvertToXmlEx("Version", xRoot, Version);
switch (serializationType)
{
case SerializationTypeEnum.All:
SaveWorkSpace(xRoot);
SaveChartPanels(xRoot);
SaveSeries(xRoot);
SaveSeriesData(xRoot);
SaveIndicators(xRoot);
SaveLineStudies(xRoot);
break;
case SerializationTypeEnum.General:
SaveWorkSpace(xRoot);
SaveIndicators(xRoot);
SaveLineStudies(xRoot);
break;
case SerializationTypeEnum.Objects:
SaveLineStudies(xRoot);
SaveIndicators(xRoot);
break;
case SerializationTypeEnum.Indicators:
SaveIndicators(xRoot);
break;
}
using (MemoryStream ms = new MemoryStream())
{
using (ZipOutputStream zipStream = new ZipOutputStream(ms))
{
zipStream.SetLevel(9);
ZipEntry entry = new ZipEntry("root");
zipStream.PutNextEntry(entry);
MemoryStream xStream = new MemoryStream();
xDocument.Save(xStream);
xStream.Seek(0, SeekOrigin.Begin);
byte[] buffer = new byte[4096];
StreamUtils.Copy(xStream, zipStream, buffer);
}
return(ms.GetBuffer());
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(null);
}
}
/// <summary>
///
///</summary>
///<param name="serializationType"></param>
///<returns></returns>
public byte[] Save(SerializationTypeEnum serializationType)
{
byte[] ret = null;
try
{
XmlDocument xmlDocument = new XmlDocument();
XmlElement xRoot = xmlDocument.CreateElement("StockChartX");
xmlDocument.AppendChild(xRoot);
ConvertToXmlEx("Version", xRoot, xmlDocument, Version);
XmlAttribute xmlAttribute = xmlDocument.CreateAttribute("SaveType");
xmlAttribute.Value = serializationType.ToString();
xRoot.Attributes.Append(xmlAttribute);
switch (serializationType)
{
case SerializationTypeEnum.All:
SaveWorkSpace(xRoot, xmlDocument);
SaveChartPanels(xRoot, xmlDocument);
SaveSeries(xRoot, xmlDocument);
SaveSeriesData(xRoot, xmlDocument);
SaveIndicators(xRoot, xmlDocument);
SaveLineStudies(xRoot, xmlDocument);
break;
case SerializationTypeEnum.General:
SaveWorkSpace(xRoot, xmlDocument);
SaveIndicators(xRoot, xmlDocument);
SaveLineStudies(xRoot, xmlDocument);
break;
case SerializationTypeEnum.Objects:
SaveLineStudies(xRoot, xmlDocument);
SaveIndicators(xRoot, xmlDocument);
break;
case SerializationTypeEnum.Indicators:
SaveIndicators(xRoot, xmlDocument);
break;
}
using (MemoryStream stream = new MemoryStream())
{
using (XmlTextWriter xmlWriter = new XmlTextWriter(stream, Encoding.UTF8)
{
Formatting = Formatting.Indented
})
{
xmlDocument.Save(xmlWriter);
ret = stream.ToArray();
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(ret);
}
protected byte[] SerializeItem(T item, SerializationTypeEnum serializationType)
{
switch (serializationType)
{
case SerializationTypeEnum.BinaryFormatter:
using (var mx = new MemoryStream())
{
_binaryFormatter.Serialize(mx, item);
return(mx.ToArray());
}
case SerializationTypeEnum.NewtonsoftJson:
return(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(item, settings)));
case SerializationTypeEnum.DataContractJsonSerializer:
using (var mx = new MemoryStream())
{
_dataContractJsonSerializer.WriteObject(mx, item);
return(mx.ToArray());
}
case SerializationTypeEnum.Xml:
using (var mx = new MemoryStream())
{
_xmlSerializer.Serialize(mx, item);
return(mx.ToArray());
}
default:
throw new ArgumentException(
string.Format("Unknown serialization type {0}", serializationType));
}
}
public static T DeserializeFromString <T>(string p_textObject, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
T v_desserializedObject = default(T);
try
{
if (EqualityComparer <T> .Default.Equals(v_desserializedObject, default(T)) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.BSON))
{
v_desserializedObject = DeserializeBSONFromString <T>(p_textObject);
}
if (EqualityComparer <T> .Default.Equals(v_desserializedObject, default(T)) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.JSON))
{
v_desserializedObject = DeserializeJSONFromString <T>(p_textObject);
}
if (EqualityComparer <T> .Default.Equals(v_desserializedObject, default(T)) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.BXML))
{
v_desserializedObject = DeserializeBXMLFromString <T>(p_textObject);
}
if (EqualityComparer <T> .Default.Equals(v_desserializedObject, default(T)) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.XML))
{
v_desserializedObject = DeserializeXMLFromString <T>(p_textObject);
}
}
catch {}
return(v_desserializedObject);
}
public static string SerializeToString <T>(T p_object, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
string v_textObject = "";
try
{
if (string.IsNullOrEmpty(v_textObject) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.BSON))
{
v_textObject = SerializeBSONToString <T>(p_object);
}
if (string.IsNullOrEmpty(v_textObject) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.JSON))
{
v_textObject = SerializeJSONToString <T>(p_object);
}
if (string.IsNullOrEmpty(v_textObject) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.BXML))
{
v_textObject = SerializeBXMLToString <T>(p_object);
}
if (string.IsNullOrEmpty(v_textObject) && (p_serializationType == SerializationTypeEnum.AutoDetect || p_serializationType == SerializationTypeEnum.XML))
{
v_textObject = SerializeXMLToString <T>(p_object);
}
}
catch {}
return(v_textObject);
}
public static T DeserializeFromPlayerPrefs <T>(string p_key, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
T v_desserializedObject = default(T);
try
{
string v_fileText = ReadAllTextFromPlayerPrefs(p_key);
v_desserializedObject = DeserializeFromString <T>(v_fileText, p_serializationType);
}
catch {}
return(v_desserializedObject);
}
//Always Serialize Outside Resources in Phone Devices
public static bool SerializeToPlayerPrefs <T>(T p_object, string p_key, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
bool v_sucess = false;
try
{
string v_stringObject = SerializeToString(p_object, p_serializationType);
WriteAllTextToPlayerPrefs(v_stringObject, p_key);
}
catch {}
return(v_sucess);
}
public static T Deserialize <T>(string p_fullPathWithFileName, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
T v_desserializedObject = default(T);
try
{
string v_fileText = ReadAllText(p_fullPathWithFileName);
v_desserializedObject = DeserializeFromString <T>(v_fileText, p_serializationType);
}
catch {}
return(v_desserializedObject);
}
//Always Serialize Outside Resources in Phone Devices
public static bool Serialize <T>(T p_object, string p_fullPathWithFileName, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
bool v_sucess = false;
try
{
string v_resultPath = p_fullPathWithFileName;
string v_stringObject = SerializeToString(p_object, p_serializationType);
WriteAllText(v_stringObject, v_resultPath);
}
catch {}
return(v_sucess);
}
///<summary>
/// Save's the chart into a given file name.
///</summary>
///<param name="filename">File name where to save</param>
///<param name="serializationType">Type of serialization to use.</param>
/// <returns>true - if file was succesfully saved. false - otherwise</returns>
public bool SaveFile(string filename, SerializationTypeEnum serializationType)
{
try
{
XmlDocument xmlDocument = new XmlDocument();
XmlElement xRoot = xmlDocument.CreateElement("StockChartX");
xmlDocument.AppendChild(xRoot);
ConvertToXmlEx("Version", xRoot, xmlDocument, Version);
XmlAttribute xmlAttribute = xmlDocument.CreateAttribute("SaveType");
xmlAttribute.Value = serializationType.ToString();
xRoot.Attributes.Append(xmlAttribute);
switch (serializationType)
{
case SerializationTypeEnum.All:
SaveWorkSpace(xRoot, xmlDocument);
SaveChartPanels(xRoot, xmlDocument);
SaveSeries(xRoot, xmlDocument);
SaveSeriesData(xRoot, xmlDocument);
SaveIndicators(xRoot, xmlDocument);
SaveLineStudies(xRoot, xmlDocument);
break;
case SerializationTypeEnum.General:
SaveWorkSpace(xRoot, xmlDocument);
SaveIndicators(xRoot, xmlDocument);
SaveLineStudies(xRoot, xmlDocument);
break;
case SerializationTypeEnum.Objects:
SaveLineStudies(xRoot, xmlDocument);
SaveIndicators(xRoot, xmlDocument);
break;
case SerializationTypeEnum.Indicators:
SaveIndicators(xRoot, xmlDocument);
break;
}
using (FileStream fileStream = File.Create(filename))
{
using (GZipStream zipStream = new GZipStream(fileStream, CompressionMode.Compress))
{
using (XmlTextWriter xmlWriter = new XmlTextWriter(zipStream, Encoding.UTF8)
{
Formatting = Formatting.Indented
})
{
xmlDocument.Save(xmlWriter);
}
}
}
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(false);
}
}
/// <summary>
/// open's a chart file
/// </summary>
/// <param name="filename">File name</param>
/// <param name="serializationType">Serialization type</param>
/// <returns>
/// 0 - no errors
/// -1 - root element is null
/// -2 - wrong serialization type
/// -3 - un-suported serialization type
/// -4 - un-suported version of file
/// -5 - unknown exception
/// </returns>
public int LoadFile(string filename, SerializationTypeEnum serializationType)
{
try
{
Status = ChartStatus.Building;
using (FileStream fileStream = File.OpenRead(filename))
{
using (GZipStream zipStream = new GZipStream(fileStream, CompressionMode.Decompress))
{
using (XmlTextReader xmlTextReader = new XmlTextReader(zipStream))
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(xmlTextReader);
XmlNode xRoot = xmlDocument.DocumentElement;
if (xRoot == null)
{
return(-1);
}
int version = ConvertFromXmlEx("Version", xRoot, 0);
SerializationTypeEnum serializationTypeEnum = (SerializationTypeEnum)Enum.Parse(typeof(SerializationTypeEnum), xRoot.Attributes["SaveType"].Value);
if (serializationTypeEnum != serializationType)
{
return(-2);
}
if (version == 100)
{
switch (serializationType)
{
case SerializationTypeEnum.All:
ReadWorkSpace(xRoot);
ReadChartPanels(xRoot);
ReadSeries(xRoot);
ReadSeriesData(xRoot);
ReadIndicators(xRoot);
ReadLineStudies(xRoot);
break;
case SerializationTypeEnum.General:
ReadWorkSpace(xRoot);
ReadIndicators(xRoot);
ReadLineStudies(xRoot);
break;
case SerializationTypeEnum.Objects:
// ReadChartPanels(xRoot);
ReadLineStudies(xRoot);
ReadIndicators(xRoot);
break;
case SerializationTypeEnum.Indicators:
ReadIndicators(xRoot);
break;
default:
return(-3);
}
}
else
{
return(-4);
}
}
}
}
Status = ChartStatus.Ready;
_panelsContainer.ResizePanels(PanelsContainer.ResizeType.Proportional);
return(0);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(-5);
}
finally
{
Status = ChartStatus.Ready;
}
}
///<summary>
///</summary>
///<param name="buffer"></param>
///<param name="serializationType"></param>
///<returns></returns>
public int Load(byte[] buffer, SerializationTypeEnum serializationType)
{
try
{
Status = ChartStatus.Building;
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
using (XmlTextReader xmlTextReader = new XmlTextReader(memoryStream))
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(xmlTextReader);
XmlNode xRoot = xmlDocument.DocumentElement;
if (xRoot == null)
{
return(-1);
}
int version = ConvertFromXmlEx("Version", xRoot, 0);
SerializationTypeEnum serializationTypeEnum = (SerializationTypeEnum)Enum.Parse(typeof(SerializationTypeEnum), xRoot.Attributes["SaveType"].Value);
if (serializationTypeEnum != serializationType)
{
return(-2);
}
if (version == 100)
{
switch (serializationType)
{
case SerializationTypeEnum.All:
ReadWorkSpace(xRoot);
ReadChartPanels(xRoot);
ReadSeries(xRoot);
ReadSeriesData(xRoot);
ReadIndicators(xRoot);
ReadLineStudies(xRoot);
break;
case SerializationTypeEnum.General:
ReadWorkSpace(xRoot);
ReadIndicators(xRoot);
ReadLineStudies(xRoot);
break;
case SerializationTypeEnum.Objects:
// ReadChartPanels(xRoot);
ReadLineStudies(xRoot);
ReadIndicators(xRoot);
break;
case SerializationTypeEnum.Indicators:
ReadIndicators(xRoot);
break;
default:
return(-3);
}
}
else
{
return(-4);
}
}
}
return(0);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(-5);
}
finally
{
Status = ChartStatus.Ready;
}
}
/// <summary>
/// Deserialize a chart from binary data
/// </summary>
/// <param name="data"></param>
/// <param name="serializationType">Serialization type</param>
/// <returns>
/// 0 - no errors
/// -1 - root element is null
/// -2 - wrong serialization type
/// -3 - un-suported serialization type
/// -4 - un-suported version of file
/// -5 - unknown exception
/// </returns>
public int LoadFile(byte[] data, SerializationTypeEnum serializationType)
{
try
{
Status = ChartStatus.Building;
using (MemoryStream ms = new MemoryStream(data))
{
using (ZipInputStream zipStream = new ZipInputStream(ms))
{
ZipEntry entry = zipStream.GetNextEntry();
if (entry == null)
{
return(-1);
}
using (MemoryStream xStream = new MemoryStream())
{
int size = 4096;
byte [] buffer = new byte[size];
while ((size = zipStream.Read(buffer, 0, buffer.Length)) > 0)
{
xStream.Write(buffer, 0, size);
}
xStream.Seek(0, SeekOrigin.Begin);
XDocument xDocument = XDocument.Load(xStream);
XElement xRoot = xDocument.Root;
if (xRoot == null)
{
return(-1);
}
int version = ConvertFromXmlEx("Version", xRoot, 0);
SerializationTypeEnum serializationTypeEnum = (SerializationTypeEnum)System.Enum.Parse(typeof(SerializationTypeEnum),
xRoot.Attributes("SaveType").First().Value, true);
if (serializationTypeEnum != serializationType)
{
return(-2);
}
if (version == 100)
{
switch (serializationType)
{
case SerializationTypeEnum.All:
ReadWorkSpace(xRoot);
ReadChartPanels(xRoot);
ReadSeries(xRoot);
ReadSeriesData(xRoot);
ReadIndicators(xRoot);
ReadLineStudies(xRoot);
break;
case SerializationTypeEnum.General:
SaveWorkSpace(xRoot);
SaveIndicators(xRoot);
SaveLineStudies(xRoot);
break;
case SerializationTypeEnum.Objects:
SaveLineStudies(xRoot);
SaveIndicators(xRoot);
break;
case SerializationTypeEnum.Indicators:
SaveIndicators(xRoot);
break;
default:
return(-3);
}
}
else
{
return(-4);
}
}
}
}
return(0);
}
catch (Exception ex)
{
Debug.WriteLine("Could not desirialize. Error: " + ex.Message);
return(-5);
}
finally
{
Status = ChartStatus.Ready;
}
}
public static void SaveToBase(SerializationTypeEnum p_serializationType)
{
SerializerHelper.Serialize <KeySaveStruct>(BaseSaveStruct, "", m_baseSaveFileName, true, p_serializationType);
}
public static T Deserialize <T>(string p_folder, string p_file, bool p_folderIsRelativePath = true, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
string v_resultPath = KiltUtils.GetCompleteDataPath(p_folder, p_file, p_folderIsRelativePath);
T v_desserializedObject = Deserialize <T>(v_resultPath, p_serializationType);
return(v_desserializedObject);
}
//Always Serialize Outside Resources in Phone Devices
public static bool Serialize <T>(T p_object, string p_folder, string p_file, bool p_folderIsRelativePath = true, SerializationTypeEnum p_serializationType = SerializationTypeEnum.AutoDetect)
{
string v_resultPath = KiltUtils.GetCompleteDataPath(p_folder, p_file, p_folderIsRelativePath);
return(Serialize <T>(p_object, v_resultPath, p_serializationType));
}
