public void Close()
{
lock (commitLock) {
CleanUp();
StoreSystem.SetCheckPoint();
// Go through and close all the committed tables.
foreach (var source in tableSources.Values)
{
source.Close(false);
}
StateStore.Flush();
StoreSystem.CloseStore(stateStore);
//tableSources = null;
IsClosed = true;
}
// Release the storage system
StoreSystem.Unlock(StateStoreName);
if (LargeObjectStore != null)
{
StoreSystem.CloseStore(lobStore);
}
}
public void Delete()
{
lock (commitLock) {
// We possibly have things to clean up.
CleanUp();
// Go through and delete and close all the committed tables.
foreach (var source in tableSources.Values)
{
source.Drop();
}
// Delete the state file
StateStore.Flush();
StoreSystem.CloseStore(stateStore);
StoreSystem.DeleteStore(stateStore);
// Delete the blob store
if (LargeObjectStore != null)
{
StoreSystem.CloseStore(lobStore);
StoreSystem.DeleteStore(lobStore);
}
//tableSources = null;
IsClosed = true;
}
// Release the storage system.
StoreSystem.Unlock(StateStoreName);
}
public void Open()
{
if (!Exists())
{
throw new IOException("Table composite does not exist");
}
// Check the file Lock
if (!IsReadOnly)
{
// Obtain the Lock (generate error if this is not possible)
StoreSystem.Lock(StateStoreName);
}
// Open the state store
stateStore = StoreSystem.OpenStore(StateStoreName);
StateStore = new TableStateStore(stateStore);
// Get the fixed 64 byte area.
var fixedArea = stateStore.GetArea(-1);
long headP = fixedArea.ReadInt8();
StateStore.Open(headP);
Setup();
InitObjectStore();
ReadVisibleTables();
ReadDroppedTables();
CleanUp();
}
public void Buy(int id)
{
if (id < 0 || id >= packList.Length || packList[id].pack == null)
{
return;
}
StoreSystem.BuyItem(packList[id].pack);
}
internal void Close(bool dropPending)
{
if (IsClosed)
{
return;
}
lock (this) {
// NOTE: This method MUST be synchronized over the table to prevent
// establishing a root Lock on this table. If a root Lock is established
// then the collection event could fail.
lock (recordList) {
// If we are root locked, we must become un root locked.
ClearLocks();
try {
try {
Store.Lock();
// Force a garbage collection event.
if (!IsReadOnly)
{
GC.Collect(true);
}
// If we are closing pending a drop, we need to remove all blob
// references input the table.
// NOTE: This must only happen after the above collection event.
if (dropPending)
{
// Scan and remove all blob references for this dropped table.
ReleaseObjects();
}
} finally {
Store.Unlock();
}
} catch (Exception) {
// TODO: Register the error to the logs
}
// Synchronize the store
indexSetStore.Close();
// Close the store input the store system.
StoreSystem.CloseStore(Store);
// TableInfo = null;
IsClosed = true;
}
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (StoreSystem != null)
{
StoreSystem.Dispose();
}
}
StoreSystem = null;
base.Dispose(disposing);
}
void Start()
{
uiController = UiController.instance;
storeSystem = GetComponentInParent <StoreSystem>();
if (itensSO != null)
{
typeImage.sprite = itensSO.productTypeImage;
nameText.text = itensSO.productName;
valueText.text = "x " + itensSO.productValue.ToString();
thisTypeItem = itensSO.thisType;
mainImage.sprite = itensSO.productImage;
stats = PlayerBehaviour.instance;
}
}
private void InitObjectStore()
{
// Does the file already exist?
bool blobStoreExists = StoreSystem.StoreExists(ObjectStoreName);
// If the blob store doesn't exist and we are read_only, we can't do
// anything further so simply return.
if (!blobStoreExists && IsReadOnly)
{
return;
}
// The blob store,
// TODO: Support store-level configuration?
if (blobStoreExists)
{
lobStore = StoreSystem.OpenStore(ObjectStoreName, new Configuration());
}
else
{
lobStore = StoreSystem.CreateStore(ObjectStoreName, new Configuration());
}
try {
lobStore.Lock();
// TODO: have multiple BLOB stores
LargeObjectStore = new LargeObjectStore(0, lobStore);
// Get the 64 byte fixed area
var fixedArea = lobStore.GetArea(-1, false);
// If the blob store didn't exist then we need to create it here,
if (!blobStoreExists)
{
long headerP = LargeObjectStore.Create();
fixedArea.Write(headerP);
fixedArea.Flush();
}
else
{
// Otherwise we need to initialize the blob store
long headerP = fixedArea.ReadInt64();
LargeObjectStore.Open(headerP);
}
} finally {
lobStore.Unlock();
}
}
internal bool Drop()
{
lock (this) {
lock (recordList) {
if (!IsClosed)
{
Close(true);
}
if (StoreSystem.DeleteStore(Store))
{
// TODO: log this
return(true);
}
return(false);
}
}
}
public void Commit(ITransaction transaction)
{
var selectedFromTables = transaction.State.SelectedTables;
var touchedTables = transaction.State.AccessedTables;
var commit = new TransactionCommit(this, transaction, selectedFromTables, touchedTables, transaction.Registry);
if (!commit.HasTableChanges)
{
CloseTransaction(transaction);
return;
}
lock (commitLock) {
var objectStates = new List <ObjectCommitState>();
var changedTablesList = commit.Execute(objectStates);
// Flush the journals up to the minimum commit id for all the tables
// that this transaction changed.
long minCommitId = Database.OpenTransactions.MinimumCommitId(null);
foreach (var master in changedTablesList)
{
master.MergeChanges(minCommitId);
}
int nsjsz = objectStates.Count;
for (int i = nsjsz - 1; i >= 0; --i)
{
var namespaceJournal = objectStates[i];
// Remove if the commit id for the journal is less than the minimum
// commit id
if (namespaceJournal.CommitId < minCommitId)
{
objectStates.RemoveAt(i);
}
}
// Set a check point in the store system. This means that the
// persistance state is now stable.
StoreSystem.SetCheckPoint();
}
}
public void Dispose()
{
if (FieldCache != null)
{
FieldCache.Clear();
}
if (headerArea != null)
{
headerArea.Dispose();
}
if (recordList != null)
{
recordList.Dispose();
}
if (Registries != null)
{
Registries.Dispose();
}
if (indexSetStore != null)
{
indexSetStore.Dispose();
}
if (Store != null)
{
if (StoreSystem.CloseStore(Store))
{
Store.Dispose();
}
}
headerArea = null;
recordList = null;
Registries = null;
indexSetStore = null;
}
internal void Commit(Transaction transaction, IList <ITableSource> visibleTables,
IEnumerable <ITableSource> selectedFromTables,
IEnumerable <IMutableTable> touchedTables, TransactionRegistry journal)
{
var state = new TransactionWork(this, transaction, selectedFromTables, touchedTables, journal);
// Exit early if nothing changed (this is a Read-only transaction)
if (!state.HasChanges)
{
CloseTransaction(state.Transaction);
return;
}
lock (commitLock) {
var changedTablesList = state.Commit(objectStates);
// Flush the journals up to the minimum commit id for all the tables
// that this transaction changed.
long minCommitId = Database.TransactionFactory.OpenTransactions.MinimumCommitId(null);
foreach (var master in changedTablesList)
{
master.MergeChanges(minCommitId);
}
int nsjsz = objectStates.Count;
for (int i = nsjsz - 1; i >= 0; --i)
{
var namespaceJournal = objectStates[i];
// Remove if the commit id for the journal is less than the minimum
// commit id
if (namespaceJournal.CommitId < minCommitId)
{
objectStates.RemoveAt(i);
}
}
// Set a check point in the store system. This means that the
// persistance state is now stable.
StoreSystem.SetCheckPoint();
}
}
void Start()
{
instance = this;
int c = TableLocator.probsTable.Find("Prob").cars.Count;
carProb = new float[c];
for (int i = 0; i < c; i++)
{
carProb[i] = TableLocator.probsTable.Find("Prob").cars[i].Value;
}
int f = TableLocator.probsTable.Find("Prob").furnitures.Count;
furnitureProb = new float[f];
for (int i = 0; i < f; i++)
{
furnitureProb[i] = TableLocator.probsTable.Find("Prob").furnitures[i].Value;
}
}
private void CreateTable()
{
// Initially set the table sequence_id to 1
sequenceId = 1;
// Create and open the store.
// TODO: have a table-level configuration?
Store = StoreSystem.CreateStore(StoreName, new Configuration());
try {
Store.Lock();
// Setup the list structure
recordList = new FixedRecordList(Store, 12);
} finally {
Store.Unlock();
}
// Initialize the store to an empty state,
SetupInitialStore();
indexSetStore.PrepareIndexes(TableInfo.Columns.Count + 1, 1, 1024);
}
private void MinimalCreate(IEnumerable <ISystemFeature> features)
{
if (Exists())
{
throw new IOException("Composite already exists");
}
// Lock the store system (generates an IOException if exclusive Lock
// can not be made).
if (!IsReadOnly)
{
StoreSystem.Lock(StateStoreName);
}
// Create/Open the state store
// TODO: Support store-level configuration?
stateStore = StoreSystem.CreateStore(StateStoreName, new Configuration());
try {
stateStore.Lock();
StateStore = new TableStateStore(stateStore);
long headP = StateStore.Create();
// Get the fixed area
var fixedArea = stateStore.GetArea(-1);
fixedArea.Write(headP);
fixedArea.Flush();
} finally {
stateStore.Unlock();
}
Setup();
// Init the conglomerate blob store
InitObjectStore();
// Create the system table (but don't initialize)
CreateSystem(features);
}
internal void MinimalCreate()
{
if (Exists())
{
throw new IOException("Composite already exists");
}
// Lock the store system (generates an IOException if exclusive Lock
// can not be made).
if (!IsReadOnly)
{
StoreSystem.Lock(StateStoreName);
}
// Create/Open the state store
stateStore = StoreSystem.CreateStore(StateStoreName);
try {
stateStore.Lock();
StateStore = new TableStateStore(stateStore);
long headP = StateStore.Create();
// Get the fixed area
var fixedArea = stateStore.GetArea(-1);
fixedArea.WriteInt8(headP);
fixedArea.Flush();
} finally {
stateStore.Unlock();
}
Setup();
// Init the conglomerate blob store
InitObjectStore();
// Create the system table (but don't initialize)
CreateSystemSchema();
}
public void Buy()
{
StoreSystem.BuyItem(pack);
}
public bool Exists() => StoreSystem.StoreExists(StateStoreName);
public bool Exists()
{
return(StoreSystem.StoreExists(StateStoreName));
}
