public void Load(IPersistable persistable)
{
using (BinaryReader reader = new BinaryReader(File.Open(_savePath, FileMode.Open)))
{
persistable.Load(new GameDataReader(reader));
}
}
public void Stop()
{
LLSDMap dictionary = new LLSDMap(server.PersistentExtensions.Count);
for (int i = 0; i < server.PersistentExtensions.Count; i++)
{
IPersistable persistable = server.PersistentExtensions[i];
Logger.DebugLog("Storing persistant data for " + persistable.ToString());
dictionary.Add(persistable.ToString(), persistable.Serialize());
}
try
{
XmlTextWriter writer = new XmlTextWriter(server.DataDir + "simiandata.xml", System.Text.Encoding.UTF8);
writer.Formatting = Formatting.Indented;
writer.WriteStartElement("llsd");
LLSDParser.SerializeXmlElement(writer, dictionary);
writer.WriteEndElement();
writer.Close();
}
catch (Exception ex)
{
Logger.Log("Failed to save persistance data: " + ex.Message, Helpers.LogLevel.Error);
}
}
public void Save(IPersistable persistable)
{
using (BinaryWriter writer = new BinaryWriter(File.Open(_savePath, FileMode.Create)))
{
persistable.Save(new GameDataWriter(writer));
}
}
public void Save(IPersistable build)
{
using (var fileStream = new FileStream(Source, FileMode.Open, FileAccess.ReadWrite))
{
if (fileStream.Length > 0) //remove ] if we have content in file
{
fileStream.Seek(-1, SeekOrigin.End);
}
using (var sw = new StreamWriter(fileStream)) //add item to array
{
using (JsonWriter writer = new JsonTextWriter(sw))
{
if (sw.BaseStream.Position == 0) //begin array if this is first item
{
writer.WriteRawValue("[");
}
else //we are adding item to existing array
{
writer.WriteRawValue(",");
}
serializer.Serialize(writer, build.Data());
writer.WriteRawValue("]");
}
}
}
}
public bool TryCreateObject(ObjectType objectType, out IPersistable persistObj)
{
switch (objectType)
{
case ObjectType.ExcelRowInfo:
persistObj = new LayoutEngine.RowInfo();
break;
case ObjectType.RowItemStruct:
persistObj = new LayoutEngine.RowItemStruct();
break;
case ObjectType.TablixStruct:
persistObj = new LayoutEngine.TablixStruct();
break;
case ObjectType.TablixMemberStruct:
persistObj = new LayoutEngine.TablixMemberStruct();
break;
case ObjectType.ToggleParent:
persistObj = new ToggleParent();
break;
default:
persistObj = null;
return(false);
}
return(true);
}
public void Add(IPersistable p)
{
var dict = _itemDictionaries[p.ObjectId%_dictCount];
if (_clearAtMax && dict.Count >= _maxEntriesPerDict)
{
dict.Clear();
return;
}
try
{
if (!dict.ContainsKey(p.ObjectId))
{
dict.Add(p.ObjectId, new WeakReference(p));
}
}
catch (OutOfMemoryException)
{
if (_clearAtMax)
{
dict.Clear();
dict.Add(p.ObjectId, new WeakReference(p));
}
else
{
throw;
}
}
}
public SerializeDeclarationsCommand(RubberduckParserState state, IPersistable <SerializableProject> service, ISerializableProjectBuilder serializableProjectBuilder)
: base(LogManager.GetCurrentClassLogger())
{
_state = state;
_service = service;
_serializableProjectBuilder = serializableProjectBuilder;
}
/// <summary>
/// Adds an object to be tracked by this <see cref="ObjectStatePersister"/> and loads the previous settings
/// for the object if possible.
/// </summary>
/// <param name="key">Unique identifier of the <see cref="IPersistable"/> object.</param>
/// <param name="obj"><see cref="IPersistable"/> object to load and save the settings for.</param>
/// <exception cref="ArgumentException">An object with the given <paramref name="key"/> already exists
/// in this collection.</exception>
public void Add(string key, IPersistable obj)
{
// Add to the gui items to track
_objs.Add(key, obj);
// Check if the settings need to be restored
IValueReader valueReader;
if (_loadedNodeItems.TryGetValue(key, out valueReader))
{
try
{
obj.ReadState(valueReader);
}
catch (Exception ex)
{
// If we fail to read the state, just absorb the exception while printing an error
const string errmsg = "Failed to load settings for object `{0}` with key `{1}`: {2}";
var err = string.Format(errmsg, obj, key, ex);
log.Error(err);
Debug.Fail(err);
}
_loadedNodeItems.Remove(key);
}
}
protected string GetObjectId(IPersistable obj)
{
// The format of the object id is <type>/<path>/<objectName>
string result = obj.GetType().Name;
if (!obj.Path.StartsWith("/"))
{
result += "/";
}
result += obj.Path;
if (!result.EndsWith("/"))
{
result += "/";
}
string name = obj.Name;
if (name == null)
{
name = PersistenceNoName;
}
if (name.StartsWith("/"))
{
// "result" already ends with a slash
name = name.Substring(1);
}
return(result + name);
}
public bool TryCreateObject(ObjectType objectType, out IPersistable persistObj)
{
switch (objectType)
{
case ObjectType.StorageItem:
persistObj = new StorageItem();
break;
case ObjectType.ScalableDictionaryNode:
persistObj = new ScalableDictionaryNode();
break;
case ObjectType.ScalableDictionaryValues:
persistObj = new ScalableDictionaryValues();
break;
case ObjectType.StorableArray:
persistObj = new StorableArray();
break;
case ObjectType.ScalableHybridListEntry:
persistObj = new ScalableHybridListEntry();
break;
default:
persistObj = null;
return(false);
}
return(true);
}
private IPersistable LoadObject(string name, IPersistable obj)
{
string fileName = PersistenceUtils.GetFilename(_scope, _path, name, _extension);
FileInfo file = _scope.Context.GetResource(fileName).File;
if (!file.Exists)
{
return(null); // No such file
}
IPersistable result = obj;
lock (this.SyncRoot)
{
using (FileStream fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
AMFReader reader = new AMFReader(fs);
string typeName = reader.ReadData() as string;
result = ObjectFactory.CreateInstance(typeName) as IPersistable;
//result.Path = GetObjectPath(name, result.Name);
//result = amfDeserializer.ReadData() as IPersistable;
result.Deserialize(reader);
}
}
return(result);
}
public void Add(IPersistable p)
{
var dict = _itemDictionaries[p.ObjectId % _dictCount];
if (_clearAtMax && dict.Count >= _maxEntriesPerDict)
{
dict.Clear();
return;
}
try
{
if (!dict.ContainsKey(p.ObjectId))
{
dict.Add(p.ObjectId, new WeakReference(p));
}
}
catch (OutOfMemoryException)
{
if (_clearAtMax)
{
dict.Clear();
dict.Add(p.ObjectId, new WeakReference(p));
}
else
{
throw;
}
}
}
IPersistable GetMoveNextExecutionArgs(IPersistable executionArgs)
{
var fieldExecutionArgs = executionArgs as FieldPersistable;
var sm = StateMachineFromMoveNext;
return(new FieldPersistable(new ThisLoadable(sm), fieldExecutionArgs.Field.AsDefinedOn(sm)));
}
public bool TryCreateObject(ObjectType objectType, out IPersistable persistObj)
{
switch (objectType)
{
case ObjectType.LookupMatches:
persistObj = new LookupMatches();
break;
case ObjectType.LookupMatchesWithRows:
persistObj = new LookupMatchesWithRows();
break;
case ObjectType.LookupTable:
persistObj = new LookupTable();
break;
case ObjectType.IntermediateFormatVersion:
persistObj = new IntermediateFormatVersion();
break;
default:
persistObj = null;
return(false);
}
return(true);
}
public static bool Insert <T>(this IPersistable <T> obj, bool recursive)
{
var inserts = new List <Func <bool> >();
if (recursive)
{
var mis = obj.GetType().GetMembers().Where(m => m.CanPreserve() && !m.GetDeclarationType().IsSimpleType()).Select(m => obj.Get(m.Name));
mis.ForEach(m => {
var insert = GetInsert(m);
if (insert != null)
{
inserts.Add(insert);
}
});
if (inserts.Count > 0)
{
using (var tran = new TransactionScope()) {
inserts.ForEach(insert => insert());
DataContext.GetEntry <T>().Insert((T)obj);
tran.Complete();
return(true);
}
}
}
return(DataContext.GetEntry <T>().Insert((T)obj) > 0);
}
public void Persist(string name, IPersistable persistable)
{
if (persistable == null)
{
return;
}
try
{
var folder = GetFolder();
// Process the persistence in 2 times to avoid to corrupt persisted files.
using (var ms = new MemoryStream())
{
persistable.Persist(ms);
var buffer = ms.GetBuffer();
var length = (int)ms.Length;
if (length == 0)
{
return;
}
var filePath = GetFilePath(folder, name);
using (var writer = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Read))
writer.Write(buffer, 0, length);
}
}
catch (Exception e)
{
WriteException(name, "Exception happens during persist", e);
}
}
public InstructionBlockChain CallMethodWithReturn(MethodReference method,
ILoadable instance,
IPersistable returnValue,
params ILoadable[] arguments)
{
var type = FixTypeReference(method.DeclaringType);
method = FixMethodReference(type, method);
InstructionBlock block;
if (method.Resolve().IsStatic)
{
block = _creator.CallStaticMethod(method, returnValue, arguments);
}
else
{
block = _creator.CallInstanceMethod(method, instance, returnValue, arguments);
}
var chain = new InstructionBlockChain();
chain.Add(block);
return(chain);
}
/// <summary>
/// Get filename for persistable object.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
private string GetObjectFilename(IPersistable obj)
{
string name = obj.Name;
if (name == null)
name = MemoryStore.PersistenceNoName;
return PersistenceUtils.GetFilename(_scope, _path, name, _extension);
}
private bool SaveObject(IPersistable obj)
{
string filename = GetObjectFilename(obj);
FileInfo file = _scope.Context.GetResource(filename).File;
string path = file.DirectoryName;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
lock (this.SyncRoot)
{
MemoryStream ms = new MemoryStream();
AMFWriter writer = new AMFWriter(ms);
writer.UseLegacyCollection = false;
writer.WriteString(obj.GetType().FullName);
//amfSerializer.WriteData(ObjectEncoding.AMF0, obj);
obj.Serialize(writer);
writer.Flush();
byte[] buffer = ms.ToArray();
ms.Close();
using (FileStream fs = new FileStream(file.FullName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
{
fs.Write(buffer, 0, buffer.Length);
fs.Close();
}
}
return(true);
}
public bool TryCreateObject(ObjectType objectType, out IPersistable persistObj)
{
switch (objectType)
{
case ObjectType.WordOpenXmlTableGrid:
persistObj = new OpenXmlTableGridModel();
break;
case ObjectType.WordOpenXmlTableRowProperties:
persistObj = new OpenXmlTableRowPropertiesModel();
break;
case ObjectType.WordOpenXmlBorderProperties:
persistObj = new OpenXmlBorderPropertiesModel();
break;
case ObjectType.WordOpenXmlHeaderFooterReferences:
persistObj = new HeaderFooterReferences();
break;
default:
persistObj = null;
return(false);
}
return(true);
}
private bool SaveObject(IPersistable obj)
{
string objectFilename = this.GetObjectFilename(obj);
FileInfo file = base._scope.Context.GetResource(objectFilename).File;
string directoryName = file.DirectoryName;
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
lock (base.SyncRoot)
{
MemoryStream stream = new MemoryStream();
AMFWriter writer = new AMFWriter(stream)
{
UseLegacyCollection = false
};
writer.WriteString(obj.GetType().FullName);
obj.Serialize(writer);
writer.Flush();
byte[] buffer = stream.ToArray();
stream.Close();
using (FileStream stream2 = new FileStream(file.FullName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
{
stream2.Write(buffer, 0, buffer.Length);
stream2.Close();
}
}
return(true);
}
public static XmlNode LocateOrCreateNode(TypeReflectionCacheItem item, IPersistable instance, out bool created)
{
XmlDocument doc = systemSettings;
if (item.PersistanceInformation.File == OptionsFile.User)
{
doc = userSettings;
}
string categoryName = item.PersistanceInformation.Category;
string instanceName = instance.InstanceName;
string valueName = item.PersistanceInformation.Name;
XmlNode settingsNode = doc.SelectSingleNode("//settings");
XmlNode categoryNode = GetOrCreateNode(doc, settingsNode, "category", categoryName);
XmlNode instanceNode = GetOrCreateNode(doc, categoryNode, "instance", instanceName);
XmlNode valueNode = GetOrCreateNode(doc, instanceNode, "value", valueName, out created);
if (created)
{
SetNodeValue(valueNode, item.PersistanceInformation.DefaultValue.ToString(),
item.PersistanceInformation.Encrypted);
}
return(valueNode);
}
protected string GetObjectId(IPersistable obj)
{
string name = obj.GetType().Name;
if (!obj.Path.StartsWith("/"))
{
name = name + "/";
}
name = name + obj.Path;
if (!name.EndsWith("/"))
{
name = name + "/";
}
string str2 = obj.Name;
if (str2 == null)
{
str2 = "__null__";
}
if (str2.StartsWith("/"))
{
str2 = str2.Substring(1);
}
return(name + str2);
}
public void Restore(string name, IPersistable persistable)
{
if (persistable == null)
{
return;
}
try
{
var filePath = GetFilePath(Folder, name);
if (!File.Exists(filePath))
{
return;
}
using (var reader = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
persistable.Restore(reader);
}
}
catch (Exception e)
{
WriteException(name, "Exception happens during restore", e);
}
}
public void Save(IPersistable build)
{
using (var fileStream = new FileStream(Source, FileMode.Open, FileAccess.ReadWrite))
{
if (fileStream.Length > 0) //remove ] if we have content in file
{
fileStream.Seek(-1, SeekOrigin.End);
}
using (var sw = new StreamWriter(fileStream)) //add item to array
{
using (JsonWriter writer = new JsonTextWriter(sw))
{
if (sw.BaseStream.Position == 0) //begin array if this is first item
{
writer.WriteRawValue("[");
}
else //we are adding item to existing array
{
writer.WriteRawValue(",");
}
serializer.Serialize(writer, build.Data());
writer.WriteRawValue("]");
}
}
}
}
/// <summary>
/// Saves the specified instance the the options file(s).
/// </summary>
public void SaveInstance(IPersistable persistableObject)
{
Type t = persistableObject.GetType();
if (!typeCache.ContainsKey(t))
{
RegisterInstance(persistableObject);
}
TypeReflectionCache cache = typeCache[t];
foreach (TypeReflectionCacheItem item in cache.Properties)
{
bool created;
XmlNode valueNode = OptionsMerger.LocateOrCreateNode(item, persistableObject, out created);
object newValue = item.PropertyInfo.GetValue(persistableObject, null);
OptionsMerger.SetNodeValue(valueNode, newValue.ToString(), item.PersistanceInformation.Encrypted);
}
// Don't save the files to disk if we are currently in batch update mode.
if (!batchInProgress)
{
SaveFiles();
}
}
public async Task <int> Insert(IPersistable data)
{
data = data ?? throw new ArgumentNullException(nameof(data));
var obj = data.CastToIEXType <Earning>(Logger);
var parameters = new SqlParameter[]
{
CreateSqlParameter(RepositoryConstants.EARNING_ACTUAL_EPS, obj?.ActualEps, SqlDbType.Float, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_CONSENSUS_EPS, obj?.ConsensusEps, SqlDbType.Float, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_ANNOUNCE_TIME, obj?.AnnounceTime, SqlDbType.VarChar, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_NUMBER_OF_ESTIMATES, obj?.NumberOfEstimates, SqlDbType.BigInt, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_EPS_SURPRISE_DOLLAR, obj?.EpsSurpriseDollar, SqlDbType.Float, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_EPS_REPORT_DATE, obj?.EpsReportDate, SqlDbType.DateTimeOffset, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_FISCAL_PERIOD, obj?.FiscalPeriod, SqlDbType.VarChar, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_FISCAL_END_DATE, obj?.FiscalEndDate, SqlDbType.DateTimeOffset, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_YEAR_AGO, obj?.YearAgo, SqlDbType.Float, ParameterDirection.Input),
CreateSqlParameter(RepositoryConstants.EARNING_YEAR_AGO_CHANGE_PERCENT, obj?.YearAgoChangePercent, SqlDbType.Float, ParameterDirection.Input)
};
int result = 0;
result = await ExecuteNonQueryAsync(RepositoryConstants.SP_EARNING_INSERT, parameters);
return(result);
}
public bool MoveNext()
{
if (m_rifReader.EOS)
{
return(false);
}
m_currentNode = null;
IPersistable persistable = m_rifReader.ReadRIFObject();
switch (persistable.GetObjectType())
{
case Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.DocumentMapBeginContainer:
{
bool result = MoveNext();
m_level++;
return(result);
}
case Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.DocumentMapEndContainer:
m_level--;
return(MoveNext());
case Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.DocumentMapNode:
{
DocumentMapNode documentMapNode = (DocumentMapNode)persistable;
m_currentNode = new Microsoft.ReportingServices.OnDemandReportRendering.DocumentMapNode(documentMapNode.Label, documentMapNode.Id, m_level);
return(true);
}
default:
Global.Tracer.Assert(condition: false);
return(false);
}
}
private static List <Instruction> CreateInstanceMethodCallInstructions(
MethodReference methodReference,
ILoadable callerInstance,
IPersistable returnValue,
params ILoadable[] arguments)
{
return(CreateMethodCallInstructions(methodReference, callerInstance, returnValue, arguments));
}
void IPersistable.Init(IPersistable source)
{
this.IsDummy = false;
var template = (Template)source;
this.Name = template.Name;
this.Site = template.Site;
}
private AppointmentRepo(IPersistable persistable, List <User> users, List <Department> departments)
{
_persistable = persistable;
_appointments = _persistable.GetAppointments(users, departments);
_updateAppointmentNotification = new AppointmentNotification(_appointments, this, _persistable);
}
public void Save(IPersistable <ObjectConstructor> obj, string path)
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(Application.persistentDataPath + "/" + path);
bf.Serialize(file, obj.Save());
file.Close();
}
internal static void LoadNotNull(this IPersistable obj, SettingsStorage settings, string name)
{
var value = settings.GetValue <SettingsStorage>(name);
if (value != null)
{
obj.Load(value);
}
}
public UnitOfWork(
IRepository<Channel> channelRepository,
IRepository<Playlist> playlistRepository,
IRepository<PlaylistItem> playlistItemsRepository,
IPersistable<ChannelPlaylistLink> channelPlaylistLinks)
{
Channels = channelRepository;
Playlists = playlistRepository;
PlaylistItems = playlistItemsRepository;
ChannelPlaylistsLinks = channelPlaylistLinks;
}
/// <summary>
/// Change a persistent object in a storage.
/// </summary>
/// <param name="pObject"></param>
/// <returns></returns>
public bool Change(IPersistable pObject)
{
bool success = ChangeObjectInStorage(pObject);
if (_cachedObjects.ContainsKey(pObject.OID))
_cachedObjects[pObject.OID] = pObject;
else
_cachedObjects.Add(pObject.OID, pObject);
return success;
}
public void Save(IPersistable build)
{
if (build as ISolutionBuild != null) // Only solution builds
{
var buildData = build.Data();
Type t = buildData.GetType();
PropertyInfo p = t.GetProperty("Time");
long solutionBuildTimeMs = (long)(p.GetValue(buildData, null));
if (solutionBuildTimeMs > 100)
{
using (StringWriter sw = new StringWriter())
{
using (JsonWriter writer = new JsonTextWriter(sw))
{
serializer.Serialize(writer, buildData);
}
PtrackClient.SendJsonDocument("visualStudioReport", sw.ToString());
}
}
}
//using (var fileStream = new FileStream(Source, FileMode.Open, FileAccess.ReadWrite))
//{
// if (fileStream.Length > 0) //remove ] if we have content in file
// {
// fileStream.Seek(-1, SeekOrigin.End);
// }
// using (var sw = new StreamWriter(fileStream)) //add item to array
// {
// using (JsonWriter writer = new JsonTextWriter(sw))
// {
// if (sw.BaseStream.Position == 0) //begin array if this is first item
// {
// writer.WriteRawValue("[");
// }
// else //we are adding item to existing array
// {
// writer.WriteRawValue(",");
// }
// serializer.Serialize(writer, build.Data());
// writer.WriteRawValue("]");
// }
// }
//}
}
private IPersistable LoadObject(string name, IPersistable obj) {
string fileName = PersistenceUtils.GetFilename(_scope, _path, name, _extension);
FileInfo file = _scope.Context.GetResource(fileName).File;
if (!file.Exists)
return null;// No such file
IPersistable result = obj;
lock (this.SyncRoot) {
using (FileStream fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read)) {
AMFReader reader = new AMFReader(fs);
string typeName = reader.ReadData() as string;
result = ObjectFactory.CreateInstance(typeName) as IPersistable;
//result.Path = GetObjectPath(name, result.Name);
//result = amfDeserializer.ReadData() as IPersistable;
result.Deserialize(reader);
}
}
return result;
}
public void Add(IPersistable p, CachePriority priority = CachePriority.Normal)
{
//switch (priority)
//{
// case CachePriority.Normal:
// _lowPriorityItems.Add(p);
// break;
// case CachePriority.High:
// _highPriorityItems.Add(p);
// break;
//}
try
{
_lowPriorityItems.Add(p);
} catch(Exception ex)
{
Logging.LogWarning(BrightstarEventId.CachingError, "Encountered an error when adding object {0} to cache. Cause: {1}",
p.ObjectId, ex);
}
}
public bool TryGetValue(ulong index, out IPersistable p)
{
WeakReference weakRef;
var dict = _itemDictionaries[index%_dictCount];
if (dict.TryGetValue(index, out weakRef))
{
if (weakRef.IsAlive)
{
p = weakRef.Target as IPersistable;
if (p != null) return true;
}
// Either weakref is not live any more or the item it resolves to is not an IPersistable
// In either case we want to clear out this cache entry and return false.
dict.Remove(index);
p = null;
return false;
}
p = null;
return false;
}
protected string GetObjectId(IPersistable obj) {
// The format of the object id is <type>/<path>/<objectName>
string result = obj.GetType().Name;
if (!obj.Path.StartsWith("/"))
result += "/";
result += obj.Path;
if (!result.EndsWith("/"))
result += "/";
string name = obj.Name;
if (name == null)
name = PersistenceNoName;
if (name.StartsWith("/")) {
// "result" already ends with a slash
name = name.Substring(1);
}
return result + name;
}
private bool SaveObject(IPersistable obj) {
string filename = GetObjectFilename(obj);
FileInfo file = _scope.Context.GetResource(filename).File;
string path = file.DirectoryName;
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
lock (this.SyncRoot) {
MemoryStream ms = new MemoryStream();
AMFWriter writer = new AMFWriter(ms);
writer.UseLegacyCollection = false;
writer.WriteString(obj.GetType().FullName);
//amfSerializer.WriteData(ObjectEncoding.AMF0, obj);
obj.Serialize(writer);
writer.Flush();
byte[] buffer = ms.ToArray();
ms.Close();
using (FileStream fs = new FileStream(file.FullName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite)) {
fs.Write(buffer, 0, buffer.Length);
fs.Close();
}
}
return true;
}
/// <summary>
/// Adds an object to be tracked by this <see cref="ObjectStatePersister"/> and loads the previous settings
/// for the object if possible.
/// </summary>
/// <param name="key">Unique identifier of the <see cref="IPersistable"/> object.</param>
/// <param name="obj"><see cref="IPersistable"/> object to load and save the settings for.</param>
/// <exception cref="ArgumentException">An object with the given <paramref name="key"/> already exists
/// in this collection.</exception>
public void Add(string key, IPersistable obj)
{
// Add to the gui items to track
_objs.Add(key, obj);
// Check if the settings need to be restored
IValueReader valueReader;
if (_loadedNodeItems.TryGetValue(key, out valueReader))
{
try
{
obj.ReadState(valueReader);
}
catch (Exception ex)
{
// If we fail to read the state, just absorb the exception while printing an error
const string errmsg = "Failed to load settings for object `{0}` with key `{1}`: {2}";
var err = string.Format(errmsg, obj, key, ex);
log.Error(err);
Debug.Fail(err);
}
_loadedNodeItems.Remove(key);
}
}
void IPersistable.Init(IPersistable source)
{
this.Repository = ((SearchSetting)source).Repository;
isDummy = false;
}
public override bool Load(IPersistable obj) {
if (obj.IsPersistent)
// Already loaded
return true;
return (LoadObject(GetObjectFilename(obj), obj) != null);
}
public virtual bool Save(IPersistable obj)
{
_objects[GetObjectId(obj)] = obj;
obj.IsPersistent = true;
return true;
}
public virtual bool Load(IPersistable obj)
{
return obj.IsPersistent;
}
public override bool Save(IPersistable obj) {
if (!base.Save(obj))
return false;
bool persistent = this.SaveObject(obj);
obj.IsPersistent = persistent;
return persistent;
}
public override bool Remove(IPersistable obj) {
return base.Remove(GetObjectId(obj));
}
/// <summary>
/// Return file path for persistable object.
/// </summary>
/// <param name="obj"></param>
/// <param name="completePath"></param>
/// <returns></returns>
private string GetObjectFilePath(IPersistable obj, bool completePath) {
return PersistenceUtils.GetPath(_scope, _path);
}
/// <summary>
/// Return file path for persistable object.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
private string GetObjectFilePath(IPersistable obj) {
return GetObjectFilePath(obj, false);
}
void IPersistable.Init(IPersistable source)
{
isDummy = false;
}
//Used for Update and Delete commands
public SqlServerPersistenceCommand(Map map, IPersistable objectForProcess, SqlCommand command, CRUD cmdType)
: base(map, objectForProcess, command, cmdType)
{
}
/// <summary>
/// Removes an individual entity from the current unit of work.
/// </summary>
public void Evict(IPersistable aggregate)
{
mapper.Evict(aggregate);
}
//Used for Updates and Deletes with a persistent object, a custom command and concurrency suppport
public SqlServerPersistenceCommand(Map map, IPersistable objectForProcess, SqlCommand command, string cmdType, ConcurrencySupportType concurrency)
: base(map, objectForProcess, command, cmdType, concurrency)
{
}
void IPersistable.Init(IPersistable source)
{
this.IsDummy = false;
var template = (Template)source;
this.Name = template.Name;
this.Site = template.Site;
}
public void Save(IPersistable build)
{
SaveCount++;
}
public virtual bool Remove(IPersistable obj)
{
return Remove(GetObjectId(obj));
}
public bool TryGetValue(ulong id, out IPersistable p)
{
return _lowPriorityItems.TryGetValue(id, out p); // _highPriorityItems.TryGetValue(id, out p); // || _lowPriorityItems.TryGetValue(id, out p);
}
public void Init(IPersistable source)
{
IsDummy = false;
}
void IPersistable.Init(IPersistable source)
{
this.IsDummy = false;
var site = (Site)source;
this.Name = site.Name;
this.Parent = site.Parent;
}
