UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-18 16:27:34 +01:00
Code Issues Packages Projects Releases Wiki Activity

Revert "[storage] Possibility to store metadata with records (cursor in scripts)"

Browse Source
This commit is contained in:
Laury
2022-05-09 18:39:02 +02:00
committed by devdl11
parent 6758a95292
commit 3e42d4847a
7 changed files with 9 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
apps/code/editor_controller.cpp
View File

@@ -65,19 +65,13 @@ void EditorController::viewWillAppear() {
ViewController::viewWillAppear();
m_editorView.loadSyntaxHighlighter();
if(GlobalPreferences::sharedGlobalPreferences()->cursorSaving()) {
int offset = m_script.cursorOffset();
if (offset != -1) {
m_editorView.setCursorLocation(m_editorView.text() + offset);
} else {
m_editorView.setCursorLocation(m_editorView.text() + strlen(m_editorView.text()));
}
m_editorView.setCursorLocation(m_editorView.text() + strlen(m_editorView.text()));
} else {
m_editorView.setCursorLocation(m_editorView.text() + strlen(m_editorView.text()));
}
}
void EditorController::viewDidDisappear() {
m_script.setCursorOffset(m_editorView.cursorLocation() - m_script.content());
m_editorView.resetSelection();
m_menuController->scriptContentEditionDidFinish();
}

15
apps/code/script.cpp
View File

@@ -65,21 +65,6 @@ bool Script::nameCompliant(const char * name) {
return false;
}
uint16_t Script::cursorOffset() {
assert(!isNull());
Ion::Storage::MetadataRowHeader * metadataForRecord = Ion::Storage::sharedStorage()->metadataForRecord(*this);
if (metadataForRecord != nullptr) {
assert(metadataForRecord->metadataSize == 2);
return *((uint16_t*) metadataForRecord->data());
}
return -1;
}
void Script::setCursorOffset(uint16_t position) {
assert(!isNull());
Ion::Storage::sharedStorage()->setMetadataForRecord(*this, sizeof(uint16_t), &position);
}
uint8_t * StatusFromData(Script::Data d) {
return const_cast<uint8_t *>(static_cast<const uint8_t *>(d.buffer));
}

2
apps/code/script.h
View File

@@ -50,8 +50,6 @@ public:
void toggleAutoimportationStatus();
const char * content() const;
size_t contentSize() { return value().size - k_statusSize; }
void setCursorOffset(uint16_t position); // -1 if no metadata
uint16_t cursorOffset();
/* Fetched status */
bool fetchedFromConsole() const;

24
ion/include/ion/internal_storage.h
View File

@@ -64,7 +64,6 @@ public:
return m_fullNameCRC32 == 0;
}
const char * fullName() const;
uint32_t fullNameCRC32() const { return m_fullNameCRC32; }
ErrorStatus setBaseNameWithExtension(const char * baseName, const char * extension);
ErrorStatus setName(const char * fullName);
Data value() const;
@@ -75,19 +74,11 @@ public:
uint32_t m_fullNameCRC32;
};
struct MetadataRowHeader { // In fact, it's a struct with a method to get data
public:
char * data() const { return (char *) this + sizeof(MetadataRowHeader); }
uint32_t size() const { return sizeof(MetadataRowHeader) + metadataSize; }
uint32_t fullNameCRC32;
uint32_t metadataSize; // To fullfill alignment
MetadataRowHeader * nextRow;
};
#if ION_STORAGE_LOG
void log();
#endif
size_t availableSize(char ** endBufferReturn = nullptr);
size_t availableSize();
size_t putAvailableSpaceAtEndOfRecord(Record r);
void getAvailableSpaceFromEndOfRecord(Record r, size_t recordAvailableSpace);
uint32_t checksum();
@@ -123,11 +114,6 @@ public:
// Used by Python OS module
int numberOfRecords();
Record recordAtIndex(int index);
// Metadata
MetadataRowHeader * metadataForRecord(Record r);
bool setMetadataForRecord(Record r, int size, const void * metadata);
void removeMetadataForRecord(Record r);
protected:
InternalStorage();
/* Getters on address in buffer */
@@ -137,13 +123,6 @@ protected:
const void * valueOfRecordStarting(char * start) const;
void destroyRecord(const Record record);
struct MetadataMapHeader {
char * startOfMetadataMap() { return (char *) this - metadataMapSize + sizeof(MetadataMapHeader); }
uint8_t metadataMapSize;
uint8_t numberOfRows;
MetadataRowHeader * firstRow;
};
class RecordIterator {
public:
RecordIterator(char * start) : m_recordStart(start) {}
@@ -196,7 +175,6 @@ private:
protected:
mutable Record m_lastRecordRetrieved;
mutable char * m_lastRecordRetrievedPointer;
MetadataMapHeader * m_metadataMapHeader;
};
/* Some apps memoize records and need to be notified when a record might have

1
ion/include/ion/storage.h
View File

@@ -8,7 +8,6 @@ namespace Ion {
class Storage : public InternalStorage {
public:
using InternalStorage::Record;
using InternalStorage::MetadataRowHeader;
using InternalStorage::expExtension;
using InternalStorage::funcExtension;

152
ion/src/shared/internal_storage.cpp
View File

@@ -112,138 +112,11 @@ void InternalStorage::log() {
}
#endif
InternalStorage::MetadataRowHeader * InternalStorage::metadataForRecord(Record r) {
MetadataRowHeader * header = m_metadataMapHeader->firstRow;
for (int i = 0; i < m_metadataMapHeader->numberOfRows; i++) {
if (header->fullNameCRC32 == r.fullNameCRC32()) {
return header;
}
header = header->nextRow;
}
return nullptr;
}
void InternalStorage::removeMetadataForRecord(Record r) {
if (r.isNull()) {
return;
}
MetadataRowHeader ** rowPointer = &m_metadataMapHeader->firstRow;
MetadataRowHeader * headerToRemove = nullptr;
size_t headerToRemoveSize = 0; // We compute it now as it will be more difficult later
for (int i = 0; i < m_metadataMapHeader->numberOfRows; i++) {
if ((*rowPointer)->fullNameCRC32 == r.fullNameCRC32()) {
headerToRemove = *rowPointer;
headerToRemoveSize = headerToRemove->size();
if ((*rowPointer)->nextRow != nullptr) {
*rowPointer = (MetadataRowHeader *) ((char *) (*rowPointer)->nextRow + headerToRemove->size());
} else {
*rowPointer = nullptr;
}
break;
}
rowPointer = &(*rowPointer)->nextRow;
}
if (headerToRemove == nullptr) {
return;
}
MetadataRowHeader * header = headerToRemove->nextRow;
if (header != nullptr) {
while (header->nextRow) {
MetadataRowHeader * nextRow = header->nextRow;
header->nextRow = (MetadataRowHeader *) ((char *) header->nextRow +headerToRemoveSize);
header = nextRow;
}
}
char * startOfMetadataMap = m_metadataMapHeader->startOfMetadataMap();
uint8_t sizeToMove = (char *) headerToRemove - startOfMetadataMap;
memmove(startOfMetadataMap + headerToRemoveSize, startOfMetadataMap, sizeToMove);
m_metadataMapHeader->numberOfRows--;
m_metadataMapHeader->metadataMapSize -= headerToRemoveSize;
}
bool InternalStorage::setMetadataForRecord(Record r, int size, const void * metadata) {
int neededSize = 0;
char * endBufferPointer = nullptr;
MetadataRowHeader * headerToUpdate = nullptr;
MetadataRowHeader ** headerToUpdatePointer = nullptr;
int headerToUpdateIndex = -1;
// We find the metadata row header for this record
MetadataRowHeader ** headerPointer = &m_metadataMapHeader->firstRow;
for (int i = 0; i < m_metadataMapHeader->numberOfRows; i++) {
if ((*headerPointer)->fullNameCRC32 == r.fullNameCRC32()) {
neededSize = size - (*headerPointer)->metadataSize;
headerToUpdate = (*headerPointer);
headerToUpdatePointer = headerPointer;
headerToUpdateIndex = i;
if (neededSize > 0 && neededSize > availableSize(&endBufferPointer)) {
return false;
}
break;
}
headerPointer = &((*headerPointer)->nextRow);
}
char * startOfMetadataMap = m_metadataMapHeader->startOfMetadataMap(); // Me must compute it now because it may change
if (headerToUpdate == nullptr) { // If we didn't find a header, we need to create one
if (size != 0) {
uint8_t newRowSize = sizeof(MetadataRowHeader) + size;
if (endBufferPointer < m_buffer + k_storageSize - m_metadataMapHeader->metadataMapSize - newRowSize) {
m_metadataMapHeader->numberOfRows++;
m_metadataMapHeader->metadataMapSize += newRowSize;
headerToUpdate = (MetadataRowHeader *) ((char *) startOfMetadataMap - newRowSize);
headerToUpdate->fullNameCRC32 = r.fullNameCRC32();
headerToUpdate->nextRow = nullptr;
if (m_metadataMapHeader->numberOfRows == 0) {
m_metadataMapHeader->firstRow = headerToUpdate;
} else {
((MetadataRowHeader *) startOfMetadataMap)->nextRow = headerToUpdate;
}
} else {
return false;
}
} else {
return true;
}
}
if (neededSize != 0) { // If we must move some data to make or fill empty space
m_metadataMapHeader->metadataMapSize += neededSize;
memmove(startOfMetadataMap - neededSize, startOfMetadataMap, (char *) headerToUpdate + sizeof(MetadataRowHeader) - startOfMetadataMap);
headerToUpdate = (MetadataRowHeader *) ((char *) headerToUpdate - neededSize);
MetadataRowHeader ** headerAfterPointer = headerToUpdatePointer; // Now we update each header below the one we just updated
for (int i = headerToUpdateIndex; i < m_metadataMapHeader->numberOfRows; i++) {
(*headerAfterPointer) = (MetadataRowHeader *) ((char *) (*headerAfterPointer) - neededSize);
headerAfterPointer = &((*headerAfterPointer)->nextRow);
}
}
headerToUpdate->metadataSize = size;
memcpy(headerToUpdate->data(), metadata, size);
return true;
}
size_t InternalStorage::availableSize(char ** endBufferReturn) {
char * endBufferPointer = endBuffer();
if (endBufferReturn) {
*endBufferReturn = endBufferPointer;
}
assert(k_storageSize >= (endBufferPointer - m_buffer) + sizeof(record_size_t) + m_metadataMapHeader->metadataMapSize);
return k_storageSize-(endBufferPointer-m_buffer)-sizeof(record_size_t) - m_metadataMapHeader->metadataMapSize;
size_t InternalStorage::availableSize() {
/* TODO maybe do: availableSize(char ** endBuffer) to get the endBuffer if it
* is needed after calling availableSize */
assert(k_storageSize >= (endBuffer() - m_buffer) + sizeof(record_size_t));
return k_storageSize-(endBuffer()-m_buffer)-sizeof(record_size_t);
}
size_t InternalStorage::putAvailableSpaceAtEndOfRecord(InternalStorage::Record r) {
@@ -253,7 +126,7 @@ size_t InternalStorage::putAvailableSpaceAtEndOfRecord(InternalStorage::Record r
char * nextRecord = p + previousRecordSize;
memmove(nextRecord + availableStorageSize,
nextRecord,
(m_buffer + k_storageSize - m_metadataMapHeader->metadataMapSize - availableStorageSize) - nextRecord);
(m_buffer + k_storageSize - availableStorageSize) - nextRecord);
size_t newRecordSize = previousRecordSize + availableStorageSize;
overrideSizeAtPosition(p, (record_size_t)newRecordSize);
return newRecordSize;
@@ -475,12 +348,6 @@ InternalStorage::InternalStorage() :
assert(m_magicFooter == Magic);
// Set the size of the first record to 0
overrideSizeAtPosition(m_buffer, 0);
// Set the metadata map header at the end of the buffer
m_metadataMapHeader = (MetadataMapHeader*) (m_buffer + k_storageSize - sizeof(MetadataMapHeader));
m_metadataMapHeader->numberOfRows = 0;
m_metadataMapHeader->firstRow = nullptr;
m_metadataMapHeader->metadataMapSize = sizeof(MetadataMapHeader);
}
// PRIVATE
@@ -514,11 +381,6 @@ InternalStorage::Record::ErrorStatus InternalStorage::setFullNameOfRecord(const
notifyChangeToDelegate(record);
m_lastRecordRetrieved = record;
m_lastRecordRetrievedPointer = p;
// Update metadata map
MetadataRowHeader * row = metadataForRecord(record);
if (row != nullptr) {
row->fullNameCRC32 = Record(fullName).fullNameCRC32();
}
return Record::ErrorStatus::None;
}
return Record::ErrorStatus::RecordDoesNotExist;
@@ -590,8 +452,6 @@ void InternalStorage::destroyRecord(Record record) {
}
char * p = pointerOfRecord(record);
if (p != nullptr) {
// Erase metadata
InternalStorage::removeMetadataForRecord(record);
record_size_t previousRecordSize = sizeOfRecordStarting(p);
slideBuffer(p+previousRecordSize, -previousRecordSize);
notifyChangeToDelegate();

2
ion/src/shared/storage.cpp
View File

@@ -21,7 +21,7 @@ size_t Storage::availableSize() {
bufferSize += sizeOfRecordStarting(p);
}
}
return k_storageSize-bufferSize-sizeof(record_size_t)-InternalStorage::m_metadataMapHeader->metadataMapSize;
return k_storageSize-bufferSize-sizeof(record_size_t);
} else {
return InternalStorage::availableSize();
}