protected void Unregister(IDataPersister persister)
{
schedule += () =>
{
m_DataPersisters.Remove(persister);
};
}
/// <summary>
/// Initializes a new instance of the <see cref="LibraryManagerService" /> class.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="fileStorer">The file storer.</param>
public LibraryManagerService(IUnityContainer container, IDataPersister <StorableTaggedFile> fileStorer)
{
container.Guard("container");
fileStorer.Guard("fileStorer");
this.container = container;
this.fileStorer = fileStorer;
}
/// <summary>
/// Creates a ObservableDataPersisterDecorator wrapping an IDataPersister which can be
/// an other decorator like DefaultValueDataPersisterDecorator that manages a default value
/// </summary>
/// <param name="inner">Decoratee</param>
/// <param name="replayScheduler">Scheduler to use to replay the current value when using <see cref="ObservableDataPersisterDecorator{T}.GetAndObserve"/>.</param>
public ObservableDataPersisterDecorator(IDataPersister <T> inner, IScheduler replayScheduler)
{
_inner = inner; //.Validation().NotNull(nameof(inner));
_replayScheduler = replayScheduler; //.Validation().NotNull(nameof(replayScheduler));
_getAndObserve = BuildGetAndObserve();
}
/// <summary>
/// Unregister persister
/// </summary>
/// <param name="persister"></param>
public static void SavePersistedData(IDataPersister persister)
{
if (!m_Quitting)
{
Instance.SaveData(persister);
}
}
public static void UnregisterPersister(IDataPersister persister)
{
if (!quitting)
{
Instance.Unregister(persister);
}
}
// =========== Public Functions ===========
public void Register(IDataPersister persister)
{
schedule += () =>
{
m_DataPersisters.Add(persister);
};
}
public static void UnregisterPersister(IDataPersister _persister)
{
if (!m_Shutting_Down)
{
Instance.Unregister(_persister);
}
}
protected void Register(IDataPersister persister)
{
schedule += () =>
{
m_DataPersisters.Add(persister);
};
}
public PrimeItemsScraperJob(IPrimeItemScraper itemScraper,
IDataPersister persister,
PrimeContext context)
{
_persister = persister;
_context = context;
_itemScraper = itemScraper;
}
public void Register(IDataPersister data)
{
_dataList.Add(data);
if (_dataMap.ContainsKey(data.Key))
{
data.LoadData(_dataMap[data.Key]);
}
}
public static void DataPersisterGUI(IDataPersister dataPersister)
{
DataSettings dataSettings = dataPersister.GetDataSettings();
DataSettings.PersistenceType persistenceType = (DataSettings.PersistenceType)EditorGUILayout.EnumPopup("Persistence Type", dataSettings.persistenceType);
string dataTag = EditorGUILayout.TextField("Data Tag", dataSettings.dataTag);
dataPersister.SetPersistenceDataSettings(dataTag, persistenceType);
}
public static void RegisterPersister(IDataPersister _persister)
{
var ds = _persister.GetDataSettings();
if (!string.IsNullOrEmpty(ds.data_tag))
{
Instance.Register(_persister);
}
}
public void Setup()
{
_sut = new PrimeItemScraper();
_context = new PrimeContext(new DbContextOptionsBuilder <PrimeContext>()
.UseSqlServer("Data Source=ORD03016\\SQLEXPRESS;Integrated Security=True;Initial Catalog=WfPrimeTracker")
.Options);
_idProvider = new IdProvider();
_updater = new FieldUpdater();
_persister = new DataPersister(_context, _idProvider, _updater);
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlDocumentService" /> class.
/// </summary>
/// <param name="dataPersister">Given persister.</param>
/// <param name="dataRetriever">Given retriever.</param>
/// <param name="fromStringToUrlsTransformer">Given fromStringToUrlsTransformer.</param>
/// <param name="fromUrlToXDocumentTransformer">Given fromUrlToXDocumentTransformer.</param>
/// <exception cref="ArgumentNullException">Thrown when one of passed parameters is null.</exception>
public XmlDocumentService(IDataPersister<XDocument> dataPersister, IDataRetriever<IEnumerable<string>> dataRetriever,
ITransformer<IEnumerable<string>,
IEnumerable<URLAddress>> fromStringToUrlsTransformer,
ITransformer<IEnumerable<URLAddress>, XDocument> fromUrlToXDocumentTransformer)
{
this.dataPersister = dataPersister ?? throw new ArgumentNullException("Persister can't be null");
this.dataRetriever = dataRetriever ?? throw new ArgumentNullException("Retriever can't be null");
this.fromStringToUrlsTransformer = fromStringToUrlsTransformer ?? throw new ArgumentNullException("Deserializer can't be null");
this.fromUrlToXDocumentTransformer = fromUrlToXDocumentTransformer ?? throw new ArgumentNullException("Serializer can't be null");
}
/// <summary>
/// Save data of single persister
/// </summary>
/// <param name="persister"></param>
private void SaveData(IDataPersister persister)
{
DataSettings dataSettings = persister.GetDataSettings();
if (dataSettings.type == DataSettings.PersistenceType.ReadOnly || dataSettings.type == DataSettings.PersistenceType.DoNotPersist)
{
return;
}
Store[dataSettings.dataId] = persister.SaveData();
}
/// <summary>
/// Creates a decorator using the same default value for both read and write operations
/// </summary>
public DefaultValueDataPersisterDecorator(
IDataPersister <T> inner,
DefaultValueDataPersisterDecoratorMode mode,
T customDefaultValue = default(T),
IEqualityComparer <T> comparer = null)
{
_inner = inner;
_mode = mode;
_customDefaultValue = customDefaultValue;
_comparer = comparer ?? EqualityComparer <T> .Default;
}
public RelicRewardsScraperJob(IHtmlDocumentFetcher fetcher,
IElementFinder finder,
IElementParser parser,
IDataPersister persister,
PrimeContext context)
{
_fetcher = fetcher;
_finder = finder;
_parser = parser;
_persister = persister;
_context = context;
}
protected void Save(IDataPersister dp)
{
var dataSettings = dp.GetDataSettings();
if (dataSettings.persistenceType == DataSettings.PersistenceType.ReadOnly || dataSettings.persistenceType == DataSettings.PersistenceType.DoNotPersist)
{
return;
}
if (!string.IsNullOrEmpty(dataSettings.dataTag))
{
m_Store[dataSettings.dataTag] = dp.SaveData();
}
}
protected void Save(IDataPersister _persister)
{
var dataSettings = _persister.GetDataSettings();
if (dataSettings.persistence_type == DataSettings.PersistenceType.ReadOnly ||
dataSettings.persistence_type == DataSettings.PersistenceType.DoNotPersist)
{
return;
}
if (!string.IsNullOrEmpty(dataSettings.data_tag))
{
m_store[dataSettings.data_tag] = _persister.SaveData();
}
}
/// <summary>
/// Load data of single persister
/// </summary>
/// <param name="persister"></param>
private void LoadData(IDataPersister persister)
{
DataSettings dataSettings = persister.GetDataSettings();
if (dataSettings.type == DataSettings.PersistenceType.WriteOnly || dataSettings.type == DataSettings.PersistenceType.DoNotPersist)
{
return;
}
if (Store.ContainsKey(dataSettings.dataId))
{
persister.LoadData(Store[dataSettings.dataId]);
}
}
public static void LoadData(Scene scene)
{
IDataPersister[] persisters = GetDataPersisters(scene);
SceneData sceneData = SceneDataRepository.GetSceneData(scene);
foreach (var data in sceneData.SavedData)
{
IDataPersister persister = persisters.FirstOrDefault(p => Equals(data.Key, p.GetDataSettings().dataKey));
if (persister == null)
{
continue;
}
persister.LoadData(data.Value.Data);
}
}
/// <summary>
/// calls <see cref="ThreadedResultWorker{TArgs,TCompletedArgs}" />
/// </summary>
/// <param name="infoBuilder">The info builder.</param>
/// <param name="storageAdapter">The storage adapter.</param>
/// <param name="logger">The logger.</param>
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="threadManager">The thread manager service.</param>
/// <param name="publicTransport">The public transport.</param>
public RecursiveAsyncFileScanner(IInfoBuilder <TInfo> infoBuilder,
IDataPersister <TInfo> storageAdapter,
IConfigurationManager configurationManager,
IThreadManager threadManager,
IPublicTransport publicTransport,
ILogger logger)
: base(logger)
{
infoBuilder.Guard("infoBuilder");
storageAdapter.Guard("storageAdapter");
configurationManager.Guard("configurationManager");
threadManager.Guard("threadManagerService");
publicTransport.Guard("publicTransport");
this.infoBuilder = infoBuilder;
this.storageAdapter = storageAdapter;
this.threadManager = threadManager;
this.publicTransport = publicTransport;
pageSize = configurationManager.GetValue("PageSize", 2000, "File Scanner");
scanPaged = configurationManager.GetValue("ScanPaged", true, "File Scanner");
}
public PlanningGameManager(IMainWindow mainWindow,
OperationsQueue operationQueue,
NetworkManager networkManager,
IDataPersister dataPersister,
ViewModelParser viewModelParser)
{
_mainWindow = mainWindow;
_operationQueue = operationQueue;
_networkManager = networkManager;
_dataPersister = dataPersister;
_viewModelParser = viewModelParser;
mainWindow.WindowClosed += SaveData;
mainWindow.NetworkConnect += WindowOnNetworkConnect;
mainWindow.HostNetworkSession += WindowOnHostNetworkSession;
mainWindow.OpenProject += Window_OnOpenProject;
mainWindow.SaveProject += Window_OnSaveProject;
_operationQueue.OperationStatus += Operation_OnStatusMessage;
}
protected virtual void OnEnable()
{
m_DataPersister = (IDataPersister)target;
}
protected void Unregister(IDataPersister _persister)
{
e_schedule += () => m_data_persisters.Remove(_persister);
}
protected void Register(IDataPersister _persister)
{
e_schedule += () => m_data_persisters.Add(_persister);
}
public static void SetDirty(IDataPersister _persister)
{
Instance.Save(_persister);
}
public void Unregister(IDataPersister persister)
{
schedule += () => m_DataPersisters.Remove(persister);
}
public static void SetDirty(IDataPersister dp)
{
Instance.Save(dp);
}
public void Remove(IDataPersister data)
{
_dataList.Remove(data);
}
