public When_a_table_with_no_rows_is_immediately_followed_by_a_non_empty_one()
{
this.dataSet = new DataSet();
var tableWithNoRows = new DataTable();
tableWithNoRows.Columns.Add("Something", typeof(DateTime));
var c = new[]
{
new object[] { "Number", "Letter" },
new object[] { 9, "Z" },
new object[] { 8, "Y" }
};
this.dataSet.Tables.Add(tableWithNoRows);
this.dataSet.Tables.Add(TestData.FromMatrix(c));
this.stream = new MemoryStream();
using (var originalReader = this.dataSet.CreateDataReader())
{
DataSerializer.Serialize(this.stream, originalReader);
this.stream.Seek(0, SeekOrigin.Begin);
this.reader = DataSerializer.Deserialize(this.stream);
}
}
/// <summary>
/// Deserializes data from a savegame (or initialises new data structures when none available).
/// Called by the game on load (including a new game).
/// </summary>
public override void OnLoadData()
{
base.OnLoadData();
// Initialise building dictionary.
BuildingsABLC.levelRanges = new Dictionary <ushort, LevelRange>();
// Read data from savegame.
byte[] data = serializableDataManager.LoadData(dataID);
// Check to see if anything was read.
if (data != null && data.Length != 0)
{
// Data was read - go ahead and deserialise.
using (MemoryStream stream = new MemoryStream(data))
{
BinaryFormatter formatter = new BinaryFormatter();
// Deserialise district arrays.
DataSerializer.Deserialize <DistrictSerializer>(stream, DataSerializer.Mode.Memory);
// Deserialise building list.
DataSerializer.Deserialize <BuildingSerializer>(stream, DataSerializer.Mode.Memory);
}
}
else
{
// No data read - initialise empty data structures.
Logging.Message("no data read");
// Use the post-deserialisation method of the district data serialiser to populate arrays with defaults.
new DistrictSerializer().AfterDeserialize(null);
}
}
public void TestFixtureSetUp()
{
dataSet = new DataSet();
var tableWithNoRows = new DataTable();
tableWithNoRows.Columns.Add("Something", typeof(DateTime));
var c = new[]
{
new object[] { "Number", "Letter" },
new object[] { 9, "Z" },
new object[] { 8, "Y" }
};
dataSet.Tables.Add(tableWithNoRows);
dataSet.Tables.Add(TestData.FromMatrix(c));
stream = new MemoryStream();
using (var originalReader = dataSet.CreateDataReader())
{
DataSerializer.Serialize(stream, originalReader);
stream.Seek(0, SeekOrigin.Begin);
reader = DataSerializer.Deserialize(stream);
}
}
public override void OnLoadData()
{
base.OnLoadData();
if (ToolManager.instance.m_properties.m_mode != ItemClass.Availability.Game)
{
return;
}
if (serializableDataManager.EnumerateData().Contains(GROWSTATE_ID))
{
var growStateData = serializableDataManager.LoadData(GROWSTATE_ID);
using (var ms = new MemoryStream(growStateData)) {
var s = DataSerializer.Deserialize <GrowState>(ms, DataSerializer.Mode.Memory);
}
}
if (UserMod.IsModEnabled(1873351912UL, "Tree Precision"))
{
return;
}
if (!serializableDataManager.EnumerateData().Contains(PRECISION_ID))
{
return;
}
var data = serializableDataManager.LoadData(PRECISION_ID);
using (var ms = new MemoryStream(data)) {
var s = DataSerializer.Deserialize <Precision>(ms, DataSerializer.Mode.Memory);
}
}
private void OnTileUpdateComplete()
{
RacingEvent data;
if (DataSerializer.Deserialize(out data))
{
Dispatcher.BeginInvoke(() =>
{
data.UpdateRemainingTime();
App.MainViewModel.Circuit = data.Country + " " + data.Circuit;
App.MainViewModel.Session = data.Session;
App.MainViewModel.EventTimeStamp = data.DownloadTimestamp;
App.MainViewModel.EventStartTime = data.SessionStartTime;
App.MainViewModel.IsSessionLive = data.IsSessionLive;
TimeSpan left = TimeSpan.FromSeconds(data.RemainingTime);
App.MainViewModel.EventStartRemainingTime = left;
App.MainViewModel.CounterDays = left.Days;
App.MainViewModel.CounterHours = left.Hours;
App.MainViewModel.CounterMinutes = left.Minutes;
App.MainViewModel.CounterSeconds = left.Seconds;
});
}
}
/// <summary>Obtain plugin versions supported by Flux</summary>
/// <returns>List of products and versions currently supported by Flux.</returns>
/// <exception cref="Exceptions.FluxException">Throws for internal SDK exceptions (Network is down, etc.).</exception>
/// <exception cref="Exceptions.ConnectionFailureException">Throws if network connection is down.</exception>
/// <exception cref="Exceptions.ServerUnavailableException">Throws if Flux server is down.</exception>
/// <exception cref="Exceptions.InternalSDKException">Throws for unhandled SDK exceptions.</exception>
public PluginVersions GetSupportedVersions()
{
log.Info("Getting Supported Versions data");
var request = HttpWebClientHelper.CreateRequest(sdkMetadata, FluxApiData.EnvUrl, null);
request.Method = "GET";
try
{
using (var response = HttpWebClientHelper.GetResponse(request))
{
return(DataSerializer.Deserialize <PluginVersions>(StreamUtils.GetDecompressedResponseStream(response)));
}
}
catch (Exceptions.FluxException ex)
{
log.Error(ex);
throw;
}
catch (Exception ex)
{
log.Error(ex);
throw new Exceptions.InternalSDKException(ex.Message);
}
}
object Deserialize(string name, DataNode node, Type type, DataContext ctx)
{
if (type.IsAssignableFrom(typeof(XmlElement)))
{
// The xml content is the first child of the data node
DataItem it = node as DataItem;
if (it == null || it.ItemData.Count > 1)
{
throw new InvalidOperationException("Can't convert property to an XmlElement object.");
}
if (it.ItemData.Count == 0)
{
return(null);
}
XmlConfigurationWriter sw = new XmlConfigurationWriter();
XmlDocument doc = new XmlDocument();
return(sw.Write(doc, it.ItemData [0]));
}
if (ctx == null)
{
throw new InvalidOperationException("Can't deserialize property '" + name + "'. Serialization context not set.");
}
DataSerializer ser = new DataSerializer(ctx);
ser.SerializationContext.BaseFile = sourceFile;
object ob = ser.Deserialize(type, node);
return(ob);
}
private bool LoadSkinData()
{
Debug.Log("NS: Loading skin data!");
try
{
var data = SimulationManager.instance.m_SerializableDataWrapper.LoadData(DataKey);
if (data == null)
{
Debug.Log("NS: No data found!");
return(false);
}
NetworkSkinDataContainer dataContainer;
using (var stream = new MemoryStream(data))
{
dataContainer = DataSerializer.Deserialize <NetworkSkinDataContainer>(stream, DataSerializer.Mode.Memory, NetworkSkinsMod.ResolveSerializedType);
}
_loadErrors = dataContainer.Errors;
}
catch (Exception e)
{
_loadErrors = new NetworkSkinLoadErrors();
_loadErrors.MajorException(e);
}
return(true);
}
private void DeserializeActiveOptions()
{
var selectedData = serializableDataManager.LoadData(SelectedOptionsId);
if (selectedData == null)
{
Debug.Log("Network Skins: No select options data found!");
return;
}
try
{
using (var stream = new MemoryStream(selectedData))
{
DataSerializer.Deserialize <OptionsData>(stream, DataSerializer.Mode.Memory);
}
Debug.LogFormat("Network Skins: Selected Options loaded (Data length: {0})", selectedData.Length);
}
catch (Exception e)
{
Debug.LogException(e);
return;
}
}
public static SaveGameMetaData GetMetaDataForDateTime(DateTime needle)
{
SaveGameMetaData result = null;
foreach (Package.Asset current in PackageManager.FilterAssets(new Package.AssetType[]
{
UserAssetType.SaveGameMetaData
}))
{
if (current != null && current.isEnabled)
{
SaveGameMetaData saveGameMetaData = current.Instantiate <SaveGameMetaData>();
if (saveGameMetaData != null)
{
try
{
Stream s = saveGameMetaData.assetRef.GetStream();
SimulationMetaData mysimmeta = DataSerializer.Deserialize <SimulationMetaData>(s,
DataSerializer.Mode.File);
if (mysimmeta.m_currentDateTime.Equals(needle))
{
return(saveGameMetaData);
}
}
catch (Exception ex)
{
ex.ToString();
}
}
}
}
return(result);
}
/// <summary>
/// Deserializes data from a savegame (or initialises new data structures when none available).
/// Called by the game on load (including a new game).
/// </summary>
public override void OnLoadData()
{
base.OnLoadData();
// Read data from savegame.
byte[] data = serializableDataManager.LoadData(dataID);
// Check to see if anything was read.
if (data != null && data.Length != 0)
{
// Data was read - go ahead and deserialise.
using (MemoryStream stream = new MemoryStream(data))
{
BinaryFormatter formatter = new BinaryFormatter();
// Deserialise savegame settings.
DataSerializer.Deserialize <BOBSerializer>(stream, DataSerializer.Mode.Memory);
Logging.Message("read ", stream.Length.ToString());
}
}
else
{
// No data read.
Logging.Message("no data read");
}
}
public void OnLoadData()
{
try
{
byte[] data = serializableData.LoadData(DataID);
if (data == null)
{
Debug.Log(Mod.LogMsgPrefix + "No saved data");
return;
}
using (var stream = new MemoryStream(data))
{
DataSerializer.Deserialize <DisastersContainer.Data>(stream, DataSerializer.Mode.Memory);
DataSerializer.Deserialize <EnhancedForestFire.Data>(stream, DataSerializer.Mode.Memory);
DataSerializer.Deserialize <EnhancedThunderstorm.Data>(stream, DataSerializer.Mode.Memory);
DataSerializer.Deserialize <EnhancedSinkhole.Data>(stream, DataSerializer.Mode.Memory);
DataSerializer.Deserialize <EnhancedTsunami.Data>(stream, DataSerializer.Mode.Memory);
DataSerializer.Deserialize <EnhancedTornado.Data>(stream, DataSerializer.Mode.Memory);
DataSerializer.Deserialize <EnhancedEarthquake.Data>(stream, DataSerializer.Mode.Memory);
DataSerializer.Deserialize <EnhancedMeteorStrike.Data>(stream, DataSerializer.Mode.Memory);
}
}
catch (Exception ex)
{
Debug.Log(Mod.LogMsgPrefix + "(load error) " + ex.Message);
}
Mod.UpdateUI();
}
internal static User GetWhoAmI(IEnumerable <FluxCookie> cookies, SDKMetadata sdkMetadata)
{
if (cookies == null)
{
return(null);
}
var authCookie = cookies.FirstOrDefault(el => el.CookieName == FluxApiData.CookiesAuthName);
if (authCookie == null)
{
return(null);
}
User user = null;
var request = HttpWebClientHelper.CreateRequest(sdkMetadata, FluxApiData.WhoAmIUrl, cookies.ToList());
request.Method = "GET";
using (var response = HttpWebClientHelper.GetResponse(request))
{
user = DataSerializer.Deserialize <User>(StreamUtils.GetDecompressedResponseStream(response));
}
user.SdkMetadata = sdkMetadata;
user.Cookies = cookies.ToList();
return(user);
}
/// <summary>Update list of projects for the current user. </summary>
/// <exception cref="Exceptions.ConnectionFailureException">Throws if network connection is down.</exception>
/// <exception cref="Exceptions.UnathorizedException">Throws if provided cookies were obsolete.</exception>
/// <exception cref="Exceptions.ServerUnavailableException">Throws if Flux server is down.</exception>
/// <exception cref="Exceptions.InternalSDKException">Throws for unhandled SDK exceptions.</exception>
public void UpdateProjects()
{
var projectList = new List <Project>();
var request = HttpWebClientHelper.CreateRequest(SdkMetadata, FluxApiData.ProjectsUrl, Cookies);
request.Method = "GET";
request.Headers.Add("user", Id);
try
{
using (var response = HttpWebClientHelper.GetResponse(request))
{
projectList = DataSerializer.Deserialize <List <Project> >(StreamUtils.GetDecompressedResponseStream(response));
}
}
catch (Exceptions.FluxException ex)
{
log.Error(ex);
throw;
}
catch (Exception ex)
{
log.Error(ex);
throw new Exceptions.InternalSDKException(ex.Message);
}
Projects = projectList;
}
public void UpdateAsync()
{
RacingEvent newData, oldData;
if (DataSerializer.Deserialize(out oldData))
{
newData = oldData.DeepCopy();
if (DataChecker.IsUpToDate(newData))
{
if (DataChangeValidator.HasChanged(oldData, newData))
{
DataSerializer.Serialize(newData);
DataComplete(newData, CompletionStatus.Completed);
}
else
{
DataComplete(newData, CompletionStatus.NoChange);
}
return;
}
}
NextEventDataDownloader nextEvent = new NextEventDataDownloader();
nextEvent.OnDownloadCompleted += nextEvent_OnDownloadCompleted;
nextEvent.DownloadEventDataAsync();
}
internal static ScopedPolicy RawDeserialize(DataNode data)
{
string scope = null;
Type t = GetRegisteredType(data.Name);
if (t == null)
{
UnknownPolicy up = new UnknownPolicy(data);
return(new ScopedPolicy(typeof(UnknownPolicy), up, up.Scope));
}
bool allowDiff = false;
DataItem di = data as DataItem;
if (di != null)
{
DataValue allowDiffData = di ["allowDiffSerialize"] as DataValue;
allowDiff = allowDiffData != null && allowDiffData.Value == "True";
DataValue val = di ["scope"] as DataValue;
if (val != null)
{
scope = val.Value;
}
DataValue inh = di ["inheritsSet"] as DataValue;
if (inh != null && inh.Value == "null")
{
return(new ScopedPolicy(t, null, scope, allowDiff));
}
}
object o = Serializer.Deserialize(t, data);
return(new ScopedPolicy(t, o, scope, allowDiff));
}
public MetadataPart(ImageRow imageRow) : base(imageRow)
{
BindModel();
DataSerializer ds = new DataSerializer();
SetModel(ds.Deserialize(ImageRow.Body as string));
}
public static DataModel Load()
{
if (File.Exists(filePath))
{
return(DataSerializer.Deserialize(filePath));
}
return(new DataModel());
}
protected override void BeginProcessing()
{
if (string.IsNullOrEmpty(SettingPath))
{
SettingPath = File.Exists(Item.CURRENT_DIR_SETTING) ? Item.CURRENT_DIR_SETTING : Item.PROGRAMDATA_SETTING;
}
_setting = DataSerializer.Deserialize <EnumRunSetting>(SettingPath);
}
public void InvalidXml_ThowsSerializationException()
{
//Arrange
var serializer = new DataSerializer<DataContractTestClass>();
//Act+Assert
ActionAssert.Throws<SerializationException>(() => serializer.Deserialize("<int val=\"1\"/>"));
}
public static void ReadTransportFile(
[SqlFacet(MaxSize = 255, IsNullable = false)] SqlString fullFileName,
[SqlFacet(MaxSize = 255, IsNullable = false)] SqlString serverName,
[SqlFacet(MaxSize = 255, IsNullable = false)] SqlString databaseName,
[SqlFacet(MaxSize = 255, IsNullable = false)] SqlString tableName,
[SqlFacet(MaxSize = 255, IsNullable = false)] SqlString userName,
[SqlFacet(MaxSize = 255, IsNullable = false)] SqlString password)
{
if (fullFileName.IsNull)
{
throw new ArgumentNullException("fullFileName");
}
if (tableName.IsNull)
{
throw new ArgumentNullException("serverName");
}
if (tableName.IsNull)
{
throw new ArgumentNullException("databaseName");
}
if (tableName.IsNull)
{
throw new ArgumentNullException("tableName");
}
if (userName.IsNull)
{
throw new ArgumentNullException("userName");
}
if (password.IsNull)
{
throw new ArgumentNullException("password");
}
using (var input = new FileStream(fullFileName.Value, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var reader = new OfflineDataPackReader();
DataPack dataPack = reader.Read(input, "RRTFv6");
var dataPart = dataPack.DataParts[0];
var connectionString = string.Format(@"Server={0};Database={1};User Id={2};Password={3};", serverName, databaseName, userName, password);
using (var partStream = dataPart.GetStream())
using (var dataReader = DataSerializer.Deserialize(partStream))
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var bulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.Default, null))
{
bulkCopy.DestinationTableName = tableName.Value;
bulkCopy.BatchSize = 500;
bulkCopy.WriteToServer(dataReader);
}
}
}
}
public static List<NetworkSkinModifier> Deserialize(byte[] data, out NetworkSkinLoadErrors errors)
{
using (var stream = new MemoryStream(data))
{
var dataContainer = DataSerializer.Deserialize<Data>(stream, DataSerializer.Mode.Memory, NetworkSkinsMod.ResolveSerializedType);
errors = dataContainer.Errors;
return dataContainer.Modifiers;
}
}
public Project ReadProject(XmlReader reader)
{
DataNode data = Read(reader);
Project project = (Project)serializer.Deserialize(typeof(Project), data);
project.FileFormat = MD1ProjectService.FileFormat;
project.FileName = serializer.SerializationContext.BaseFile;
return(project);
}
internal static T ExtractAuxParams <T>(HttpWebResponse response)
{
log.Debug("Extracting aux parameters.");
var auxHeader = response.GetResponseHeader(AUX_HEADER);
var auxJsonStr = string.IsNullOrEmpty(auxHeader) ? null : Utils.DecodeHeader(auxHeader);
var auxObj = DataSerializer.Deserialize <T>(auxJsonStr);
return(auxObj);
}
public static void ReadObjectProperties(this SlnSection pset, object ob)
{
DataSerializer ser = new DataSerializer(solutionDataContext);
ser.SerializationContext.BaseFile = pset.ParentFile.FileName;
var data = ReadDataItem(pset);
ser.Deserialize(ob, data);
}
public void TestWithIEnumerable()
{
var dataToSerialize = new[] { CreateSerializationTestClass(), CreateSerializationTestClass() };
serializer = new DataSerializer();
byte[] bytes = serializer.Serialize(dataToSerialize);
CollectionAssert.AreEqual(dataToSerialize,
serializer.Deserialize <IEnumerable <SerializationTestClass> >(bytes));
}
public When_advancing_to_the_next_result_set_but_still_in_the_middle_of_the_current_one()
{
var a = new[]
{
new object[] { "Number" },
new object[] { 0 },
new object[] { 1 },
new object[] { 2 },
new object[] { 3 },
new object[] { 4 },
new object[] { 5 },
new object[] { 6 },
new object[] { 7 },
new object[] { 8 },
new object[] { 9 },
};
var b = new[]
{
new object[] { "Letter", "Number" },
new object[] { "A", 9 },
new object[] { "B", 8 },
new object[] { "C", 7 },
new object[] { "D", 6 },
new object[] { "E", 5 },
};
this.dataSet = new DataSet();
var tableWithNoRows = new DataTable();
tableWithNoRows.Columns.Add("ColumnA", typeof(Guid));
var c = new[]
{
new object[] { "Number" },
new object[] { 9 },
new object[] { 8 }
};
this.dataSet.Tables.Add(TestData.FromMatrix(a));
this.dataSet.Tables.Add(TestData.FromMatrix(b));
this.dataSet.Tables.Add(tableWithNoRows);
this.dataSet.Tables.Add(new DataTable());
this.dataSet.Tables.Add(TestData.FromMatrix(c));
this.stream = new MemoryStream();
using (var originalReader = this.dataSet.CreateDataReader())
{
DataSerializer.Serialize(this.stream, originalReader);
this.stream.Seek(0, SeekOrigin.Begin);
this.reader = DataSerializer.Deserialize(this.stream);
}
}
public void TestFixtureSetUp()
{
var a = new[]
{
new object[] { "Number" },
new object[] { 0 },
new object[] { 1 },
new object[] { 2 },
new object[] { 3 },
new object[] { 4 },
new object[] { 5 },
new object[] { 6 },
new object[] { 7 },
new object[] { 8 },
new object[] { 9 },
};
var b = new[]
{
new object[] { "Letter", "Number" },
new object[] { "A", 9 },
new object[] { "B", 8 },
new object[] { "C", 7 },
new object[] { "D", 6 },
new object[] { "E", 5 },
};
dataSet = new DataSet();
var tableWithNoRows = new DataTable();
tableWithNoRows.Columns.Add("ColumnA", typeof(Guid));
var c = new[]
{
new object[] { "Number" },
new object[] { 9 },
new object[] { 8 }
};
dataSet.Tables.Add(TestData.FromMatrix(a));
dataSet.Tables.Add(TestData.FromMatrix(b));
dataSet.Tables.Add(tableWithNoRows);
dataSet.Tables.Add(new DataTable());
dataSet.Tables.Add(TestData.FromMatrix(c));
stream = new MemoryStream();
using (var originalReader = dataSet.CreateDataReader())
{
DataSerializer.Serialize(stream, originalReader);
stream.Seek(0, SeekOrigin.Begin);
reader = DataSerializer.Deserialize(stream);
}
}
static async Task Main(string[] args)
{
var config = DataSerializer.Deserialize <Config>();
var name = args[0];
var bot = new TelegramBotClient(config.BotId);
await bot.SendTextMessageAsync(
config.ChatId,
$"Файл {name} успешно загружен!");
}
/// <summary>
/// Update local project
/// </summary>
/// <param name="obj"></param>
public void Push(string obj)
{
#if DEBUG_ON
Console.WriteLine("Push request received from server.");
#endif
try {
window.ReloadProject(DataSerializer <Project> .Deserialize(obj));
}
catch (Exception ex) { new ErrorHandler(ex); }
}
public PartiallyResolvedPart(ImageRow imageRow) : base(imageRow)
{
ResolveBoundProperties();
DataSerializer ds = new DataSerializer();
Model = ds.Deserialize(ImageRow.Body as string);
//ResolveGeneralProperties(_generalPropertiesLocation);
}
public void ValidXml_DeserializedCorrectly()
{
//Arrange
var serializer = new DataSerializer<DataContractTestClass>();
//Act
DataContractTestClass obj = serializer.Deserialize("<DataContractTestClass xmlns=\"http://schemas.datacontract.org/2004/07/JohnsonControls.Serialization.Xml\"><Value>TestValue</Value></DataContractTestClass>");
//Note that DataSerializer is very picky about the xmlns being present
//Assert
Assert.AreEqual("TestValue",obj.Value);
}
public void DataContractSerialization_RoundTrip()
{
//Arrange
var serializer = new DataSerializer<DataContractTestClass>();
var obj = new DataContractTestClass { Value = "DemoValue" };
//Act
string xml = serializer.Serialize(obj);
DataContractTestClass obj2 = serializer.Deserialize(xml);
//Assert
Assert.AreEqual(obj.Value, obj2.Value, "Round trip with DataSerializer failed");
}