public object Deserialise()
{
int t = _Read();
int u = 0;
if (t > 100)
{
u = t;
if (u <= obs.Count + 100)
{
return(obs[u]);
}
t = _Read();
}
ObjectSerialiser os = (ObjectSerialiser)srs[(SerType)t];
if (os != null)
{
if (u > 0)
{
object r = obs[u] = os(null, null); // allow for recursive structures: create and store first
return(obs[u] = os(r, this)); // we need to do it again for strings
}
return(os(null, this));
}
else
{
throw new Exception("unknown type " + t);
}
}
/// <exclude/>
public object Deserialise()
{
int t = _Read();
int u = 0;
if (t>100)
{
u = t;
if (u<=obs.Count+100)
return obs[u];
t = _Read();
}
ObjectSerialiser os = (ObjectSerialiser)srs[(SerType)t];
if (os!=null)
{
if (u>0)
{ // ?? strange bug in mono: workaround in CSTools 4.5a leads to not chaining assignments here
object r = os(null,null); // allow for recursive structures: create and store first
obs[u] = r;
r = os(r,this); // really deserialise it
obs[u] = r; // we need to store it again for strings
return r;
}
return os(null,this);
}
else
throw new Exception("unknown type "+t);
}
public static T LoadOrDefault <T>(FileDescriptor fileName, T @default, ObjectSerialiser serialiser, ProgressReporter prog)
{
T result;
TryLoad(fileName, prog, out result, @default, serialiser);
return(result);
}
private static object InvokeGenericMember(object obj, string memberName, object[] parameters)
{
Type ObjectSerialiser;
object ReturnValue;
ObjectSerialiser = GetGenericSerialiser(obj);
ReturnValue = ObjectSerialiser.InvokeMember(memberName, _BindingFlags, null, null, parameters);
return(ReturnValue);
}
public void Serialise(object o)
{
if (o == null)
{
_Write(SerType.Null);
return;
}
if (o is Encoding)
{
_Write(SerType.Encoding);
EncodingSerialise(o, this);
return;
}
Type t = o.GetType();
if (t.IsClass)
{
object p = obs[o];
if (p != null)
{
_Write((int)p);
return;
}
else
{
int e = ++id;
_Write(e);
obs[o] = e;
}
}
object so = tps[t];
if (so != null)
{
SerType s = (SerType)so;
_Write(s);
ObjectSerialiser os = (ObjectSerialiser)srs[s];
os(o, this);
}
else
{
throw new Exception("unknown type " + t.FullName);
}
}
/// <summary>
/// <see cref="Sif.Framework.Consumer.IGenericConsumer{T,PK}.Update(T)">Update</see>
/// </summary>
public virtual void Update(T obj)
{
if (!registrationService.Registered)
{
throw new InvalidOperationException("Consumer has not registered.");
}
string url = EnvironmentUtils.ParseServiceUrl(environmentTemplate) + "/" + TypeName + "s" + "/" + obj.Id;
string body = ObjectSerialiser.Serialise(obj);
string xml = HttpUtils.PutRequest(url, registrationService.AuthorisationToken, body);
if (log.IsDebugEnabled)
{
log.Debug("XML from PUT request ...");
}
if (log.IsDebugEnabled)
{
log.Debug(xml);
}
}
/// <summary>
/// <see cref="Sif.Framework.Consumer.IGenericConsumer{T,PK}.Retrieve(PK)">Retrieve</see>
/// </summary>
public virtual T Retrieve(PK id)
{
if (!registrationService.Registered)
{
throw new InvalidOperationException("Consumer has not registered.");
}
string url = EnvironmentUtils.ParseServiceUrl(environmentTemplate) + "/" + TypeName + "s" + "/" + id;
string xml = HttpUtils.GetRequest(url, registrationService.AuthorisationToken);
if (log.IsDebugEnabled)
{
log.Debug("XML from GET request ...");
}
if (log.IsDebugEnabled)
{
log.Debug(xml);
}
return(ObjectSerialiser.Deserialise(xml));
}
/// <summary>
/// <see cref="Sif.Framework.Consumer.IGenericConsumer{T,PK}.Retrieve(T)">Retrieve</see>
/// </summary>
public virtual ICollection <T> Retrieve(T obj)
{
if (!registrationService.Registered)
{
throw new InvalidOperationException("Consumer has not registered.");
}
string url = EnvironmentUtils.ParseServiceUrl(environmentTemplate) + "/" + TypeName + "s";
string body = ObjectSerialiser.Serialise(obj);
string xml = HttpUtils.PostRequest(url, registrationService.AuthorisationToken, body, "GET");
if (log.IsDebugEnabled)
{
log.Debug("XML from POST request ...");
}
if (log.IsDebugEnabled)
{
log.Debug(xml);
}
return(ListSerialiser.Deserialise(xml));
}
private static T _Deserialise <T>(Stream s, SerialisationFormat format, ObjectSerialiser serialiser, ProgressReporter prog)
{
switch (format)
{
case SerialisationFormat.MSerialiserBinary:
return(MSerialiser.DeserialiseStream <T>(s, ETransmission.Binary, new[] { serialiser }, null));
case SerialisationFormat.MSerialiserText:
return(MSerialiser.DeserialiseStream <T>(s, ETransmission.Text, new[] { serialiser }, null));
case SerialisationFormat.MSerialiserCompactBinary:
return(MSerialiser.DeserialiseStream <T>(s, ETransmission.CompactBinary, new[] { serialiser }, null));
case SerialisationFormat.MSerialiserFastBinary:
return(MSerialiser.DeserialiseStream <T>(s, ETransmission.FastBinary, new[] { serialiser }, null));
case SerialisationFormat.Xml:
var xs = _CreateXmlSerialiser <T>();
return((T)xs.Deserialize(s));
case SerialisationFormat.DataContract:
var dcs = _CreateDataContactSerialiser <T>();
return((T)dcs.ReadObject(s));
case SerialisationFormat.MsnrbfBinary:
var bcs = new BinaryFormatter();
// bcs.Binder = new TypeNameConverter(); - We don't do this anymore, backwards compatibility ends up taking most of the development time.
return((T)bcs.Deserialize(s));
case SerialisationFormat.Ini:
return(IniSerialiser.Deserialise <T>(s));
default:
throw new InvalidOperationException("Invalid switch: " + format);
}
}
public static bool TryLoad <T>(FileDescriptor fileName, ProgressReporter progress, out T result, T @default, ObjectSerialiser serialiser)
{
if (!File.Exists(fileName))
{
result = @default;
return(false);
}
try
{
using (FileStream sr = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
if (progress != null)
{
using (ProgressStream ps = new ProgressStream(sr, progress))
{
result = _Deserialise <T>(ps, fileName.Format, serialiser, progress);
}
}
else
{
result = _Deserialise <T>(sr, fileName.Format, serialiser, progress);
}
}
return(true);
}
catch
{
result = @default;
return(false);
}
}
/// <summary>
/// Saves or loads settings depending on the <paramref name="save"/> parameter.
/// When loading for the first time (i.e. if the default value is used) the file will also be saved.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="save"></param>
/// <param name="fileName"></param>
/// <param name="srcDest"></param>
/// <param name="serialiser"></param>
/// <param name="prog"></param>
public static void SaveLoad <T>(bool save, FileDescriptor fileName, ref T srcDest, ObjectSerialiser serialiser, ProgressReporter prog)
{
if (save)
{
Save(fileName, srcDest, serialiser, prog);
}
else
{
T result;
if (TryLoad(fileName, prog, out result, srcDest, serialiser))
{
srcDest = result;
return;
}
if (!File.Exists(fileName))
{
Save(fileName, srcDest, serialiser, prog);
}
}
}
public static T LoadAndResave <T>(FileDescriptor fileName, ProgressReporter prog, ObjectSerialiser serialiser)
where T : new()
{
T result;
if (!TryLoad <T>(fileName, prog, out result, default(T), serialiser))
{
result = new T();
}
Save <T>(fileName, result, null, prog);
return(result);
}
private static void _Serialise <T>(T data, Stream s, SerialisationFormat format, ObjectSerialiser serialiser, ProgressReporter prog)
{
switch (format)
{
case SerialisationFormat.MSerialiserBinary:
MSerialiser.SerialiseStream(s, data, ETransmission.Binary, new[] { serialiser }, null);
return;
case SerialisationFormat.MSerialiserText:
MSerialiser.SerialiseStream(s, data, ETransmission.Text, new[] { serialiser }, null);
return;
case SerialisationFormat.MSerialiserCompactBinary:
MSerialiser.SerialiseStream(s, data, ETransmission.CompactBinary, new[] { serialiser }, null);
return;
case SerialisationFormat.MSerialiserFastBinary:
MSerialiser.SerialiseStream(s, data, ETransmission.FastBinary, new[] { serialiser }, null);
return;
case SerialisationFormat.Xml:
var xs = _CreateXmlSerialiser <T>();
xs.Serialize(s, data);
break;
case SerialisationFormat.DataContract:
var dcs = _CreateDataContactSerialiser <T>();
dcs.WriteObject(s, (object)data);
break;
case SerialisationFormat.MsnrbfBinary:
var bcs = new BinaryFormatter();
bcs.Serialize(s, data);
break;
case SerialisationFormat.Ini:
IniSerialiser.Serialise(s, data);
break;
default:
throw new InvalidOperationException("Invalid switch: " + format);
}
}
public static void Save <T>(FileDescriptor fileName, T data, ObjectSerialiser serialiser, ProgressReporter prog)
{
// Because we move files we can write over readonly files, so prevent this here
if (File.Exists(fileName) && new FileInfo(fileName).IsReadOnly)
{
throw new InvalidOperationException($"Will not overwrite file because it is marked as readonly. Filename: {fileName}");
}
// Can't cancel halfway through writing a file
prog.DisableThrowOnCancel();
try
{
// Create backup
// Need to check main settings is initialised because this function is used when loading the main settings themselves
if (MainSettings.Instance != null && MainSettings.Instance.General.AutoBackup)
{
if (File.Exists(fileName))
{
string bakFile = fileName + ".bak";
if (File.Exists(bakFile))
{
File.Delete(bakFile);
}
File.Move(fileName, bakFile);
}
}
if (data == null)
{
// Special case for deleting files
File.Delete(fileName);
return;
}
// Save to a temporary file (in case we get an error we don't want to destroy the original by saving over it with a corrupt copy)
string tempFile = fileName + ".tmp";
try
{
using (Stream sw = new FileStream(tempFile, FileMode.Create, FileAccess.Write))
{
_Serialise <T>(data, sw, fileName.Format, serialiser, prog);
}
}
catch
{
File.Delete(tempFile);
throw;
}
// Move the temp file to the new location
File.Delete(fileName);
File.Move(tempFile, fileName);
}
finally
{
prog.ReenableThrowOnCancel();
}
}
