UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-19 00:37:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

[apps/shared] Change name StorageExpressionModel -->

Browse Source 
ExpressionModelHandle
This commit is contained in:
Émilie Feral
2019-02-21 12:50:29 +01:00
parent cef106b23d
commit 4be902be93
11 changed files with 45 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
apps/graph/storage_cartesian_function_store.cpp
View File

@@ -20,7 +20,7 @@ void StorageCartesianFunctionStore::setMemoizedModelAtIndex(int cacheIndex, Ion:
m_functions[cacheIndex] = StorageCartesianFunction(record);
}
StorageExpressionModel * StorageCartesianFunctionStore::memoizedModelAtIndex(int cacheIndex) const {
ExpressionModelHandle * StorageCartesianFunctionStore::memoizedModelAtIndex(int cacheIndex) const {
assert(cacheIndex >= 0 && cacheIndex < k_maxNumberOfMemoizedModels);
return &m_functions[cacheIndex];
}

2
apps/graph/storage_cartesian_function_store.h
View File

@@ -17,7 +17,7 @@ private:
Ion::Storage::Record::ErrorStatus addEmptyModel() override;
const char * modelExtension() const override { return Shared::GlobalContext::funcExtension; }
void setMemoizedModelAtIndex(int cacheIndex, Ion::Storage::Record record) const override;
Shared::StorageExpressionModel * memoizedModelAtIndex(int cacheIndex) const override;
Shared::ExpressionModelHandle * memoizedModelAtIndex(int cacheIndex) const override;
mutable Shared::StorageCartesianFunction m_functions[k_maxNumberOfMemoizedModels];
};

2
apps/shared/Makefile
View File

@@ -11,6 +11,7 @@ app_src += $(addprefix apps/shared/,\
editable_cell_table_view_controller.cpp \
expression_field_delegate_app.cpp \
expression_model.cpp \
expression_model_handle.cpp \
expression_model_list_controller.cpp \
expression_model_store.cpp \
float_parameter_controller.cpp \
@@ -52,7 +53,6 @@ app_src += $(addprefix apps/shared/,\
separator_even_odd_buffer_text_cell.cpp \
simple_interactive_curve_view_controller.cpp \
storage_cartesian_function.cpp \
storage_expression_model.cpp \
storage_expression_model_list_controller.cpp \
storage_expression_model_store.cpp \
storage_function.cpp \

28
apps/shared/storage_expression_model.cpp → apps/shared/expression_model_handle.cpp
View File

@@ -1,4 +1,4 @@
#include "storage_expression_model.h"
#include "expression_model_handle.h"
#include "global_context.h"
#include "poincare_helpers.h"
#include <poincare/horizontal_layout.h>
@@ -11,7 +11,7 @@ using namespace Poincare;
namespace Shared {
StorageExpressionModel::StorageExpressionModel(Storage::Record record) :
ExpressionModelHandle::ExpressionModelHandle(Storage::Record record) :
Storage::Record(record),
m_expression(),
m_layout(),
@@ -19,7 +19,7 @@ StorageExpressionModel::StorageExpressionModel(Storage::Record record) :
{
}
void StorageExpressionModel::text(char * buffer, size_t bufferSize) const {
void ExpressionModelHandle::text(char * buffer, size_t bufferSize) const {
Expression e = expressionClone();
if (e.isUninitialized() && bufferSize > 0) {
buffer[0] = 0;
@@ -28,14 +28,14 @@ void StorageExpressionModel::text(char * buffer, size_t bufferSize) const {
}
}
bool StorageExpressionModel::isCircularlyDefined(Poincare::Context * context) const {
bool ExpressionModelHandle::isCircularlyDefined(Poincare::Context * context) const {
if (m_circular == -1) {
m_circular = Expression::ExpressionWithoutSymbols(expressionClone(), *context).isUninitialized();
}
return m_circular;
}
Expression StorageExpressionModel::expressionReduced(Poincare::Context * context) const {
Expression ExpressionModelHandle::expressionReduced(Poincare::Context * context) const {
if (m_expression.isUninitialized()) {
assert(!isNull());
Ion::Storage::Record::Data recordData = value();
@@ -49,14 +49,14 @@ Expression StorageExpressionModel::expressionReduced(Poincare::Context * context
return m_expression;
}
Expression StorageExpressionModel::expressionClone() const {
Expression ExpressionModelHandle::expressionClone() const {
assert(!isNull());
Ion::Storage::Record::Data recordData = value();
/* A new Expression has to be created at each call (because it might be tempered with after calling) */
return Expression::ExpressionFromAddress(expressionAddressForValue(recordData), expressionSizeForValue(recordData));
}
Layout StorageExpressionModel::layout() {
Layout ExpressionModelHandle::layout() {
if (m_layout.isUninitialized()) {
m_layout = PoincareHelpers::CreateLayout(expressionClone());
if (m_layout.isUninitialized()) {
@@ -66,21 +66,21 @@ Layout StorageExpressionModel::layout() {
return m_layout;
}
bool StorageExpressionModel::isDefined() {
bool ExpressionModelHandle::isDefined() {
return !isEmpty();
}
bool StorageExpressionModel::isEmpty() {
bool ExpressionModelHandle::isEmpty() {
return value().size <= metaDataSize();
}
void StorageExpressionModel::tidy() {
void ExpressionModelHandle::tidy() {
m_layout = Layout();
m_expression = Expression();
m_circular = 0;
}
Ion::Storage::Record::ErrorStatus StorageExpressionModel::setContent(const char * c) {
Ion::Storage::Record::ErrorStatus ExpressionModelHandle::setContent(const char * c) {
Expression expressionToStore;
// if c = "", we want to reinit the Expression
if (c && *c != 0) {
@@ -93,7 +93,7 @@ Ion::Storage::Record::ErrorStatus StorageExpressionModel::setContent(const char
return setExpressionContent(expressionToStore);
}
Ion::Storage::Record::ErrorStatus StorageExpressionModel::setExpressionContent(Expression & expressionToStore) {
Ion::Storage::Record::ErrorStatus ExpressionModelHandle::setExpressionContent(Expression & expressionToStore) {
assert(!isNull());
// Prepare the new data to store
Ion::Storage::Record::Data newData = value();
@@ -120,11 +120,11 @@ Ion::Storage::Record::ErrorStatus StorageExpressionModel::setExpressionContent(E
return error;
}
void * StorageExpressionModel::expressionAddressForValue(Ion::Storage::Record::Data recordData) const {
void * ExpressionModelHandle::expressionAddressForValue(Ion::Storage::Record::Data recordData) const {
return (char *)recordData.buffer+metaDataSize();
}
size_t StorageExpressionModel::expressionSizeForValue(Ion::Storage::Record::Data recordData) const {
size_t ExpressionModelHandle::expressionSizeForValue(Ion::Storage::Record::Data recordData) const {
return recordData.size-metaDataSize();
}

10
apps/shared/storage_expression_model.h → apps/shared/expression_model_handle.h
View File

@@ -1,5 +1,5 @@
#ifndef SHARED_STORAGE_EXPRESSION_MODEL_H
#define SHARED_STORAGE_EXPRESSION_MODEL_H
#ifndef SHARED_EXPRESSION_MODEL_HANDLE_H
#define SHARED_EXPRESSION_MODEL_HANDLE_H
#include <poincare/context.h>
#include <poincare/expression.h>
@@ -8,12 +8,12 @@
namespace Shared {
// StorageExpressionModel is a handle to Ion::Record
// ExpressionModelHandle is a handle to Ion::Record
class StorageExpressionModel : public Ion::Storage::Record {
class ExpressionModelHandle : public Ion::Storage::Record {
// TODO find better name (once we remove ExpressionModel?)
public:
StorageExpressionModel(Ion::Storage::Record record);
ExpressionModelHandle(Ion::Storage::Record record);
void text(char * buffer, size_t bufferSize) const;
Poincare::Expression expressionReduced(Poincare::Context * context) const;
Poincare::Expression expressionClone() const;

12
apps/shared/storage_expression_model_list_controller.cpp
View File

@@ -109,7 +109,7 @@ KDCoordinate StorageExpressionModelListController::expressionRowHeight(int j) {
if (isAddEmptyRow(j)) {
return Metric::StoreRowHeight;
}
ExpiringPointer<StorageExpressionModel> m = modelStore()->modelForRecord(modelStore()->recordAtIndex(j));
ExpiringPointer<ExpressionModelHandle> m = modelStore()->modelForRecord(modelStore()->recordAtIndex(j));
if (m->layout().isUninitialized()) {
return Metric::StoreRowHeight;
}
@@ -120,7 +120,7 @@ KDCoordinate StorageExpressionModelListController::expressionRowHeight(int j) {
void StorageExpressionModelListController::willDisplayExpressionCellAtIndex(HighlightCell * cell, int j) {
EvenOddExpressionCell * myCell = (EvenOddExpressionCell *)cell;
ExpiringPointer<StorageExpressionModel> m = modelStore()->modelForRecord(modelStore()->recordAtIndex(j));
ExpiringPointer<ExpressionModelHandle> m = modelStore()->modelForRecord(modelStore()->recordAtIndex(j));
myCell->setLayout(m->layout());
}
@@ -140,7 +140,7 @@ bool StorageExpressionModelListController::handleEventOnExpression(Ion::Events::
}
if (event == Ion::Events::Backspace && !isAddEmptyRow(selectedRow())) {
Ion::Storage::Record record = modelStore()->recordAtIndex(modelIndexForRow(selectedRow()));
ExpiringPointer<StorageExpressionModel> model = modelStore()->modelForRecord(record);
ExpiringPointer<ExpressionModelHandle> model = modelStore()->modelForRecord(record);
if (model->shouldBeClearedBeforeRemove()) {
reinitExpression(model);
} else {
@@ -170,7 +170,7 @@ void StorageExpressionModelListController::addEmptyModel() {
editExpression(Ion::Events::OK);
}
void StorageExpressionModelListController::reinitExpression(ExpiringPointer<StorageExpressionModel> model) {
void StorageExpressionModelListController::reinitExpression(ExpiringPointer<ExpressionModelHandle> model) {
model->setContent("");
resetMemoization();
selectableTableView()->reloadData();
@@ -182,7 +182,7 @@ void StorageExpressionModelListController::editExpression(Ion::Events::Event eve
char initialTextContent[initialTextContentMaxSize];
if (event == Ion::Events::OK || event == Ion::Events::EXE) {
Ion::Storage::Record record = modelStore()->recordAtIndex(modelIndexForRow(selectedRow()));
ExpiringPointer<StorageExpressionModel> model = modelStore()->modelForRecord(record);
ExpiringPointer<ExpressionModelHandle> model = modelStore()->modelForRecord(record);
model->text(initialTextContent, initialTextContentMaxSize);
initialText = initialTextContent;
// Replace Poincare::Symbol::SpecialSymbols::UnknownX with 'x'
@@ -208,7 +208,7 @@ void StorageExpressionModelListController::editExpression(Ion::Events::Event eve
bool StorageExpressionModelListController::editSelectedRecordWithText(const char * text) {
Ion::Storage::Record record = modelStore()->recordAtIndex(modelIndexForRow(selectedRow()));
ExpiringPointer<StorageExpressionModel> model = modelStore()->modelForRecord(record);
ExpiringPointer<ExpressionModelHandle> model = modelStore()->modelForRecord(record);
return (model->setContent(text) == Ion::Storage::Record::ErrorStatus::None);
}

2
apps/shared/storage_expression_model_list_controller.h
View File

@@ -24,7 +24,7 @@ protected:
bool handleEventOnExpression(Ion::Events::Event event);
virtual void addEmptyModel();
virtual void didChangeModelsList() { resetMemoization(); }
virtual void reinitExpression(ExpiringPointer<StorageExpressionModel> model);
virtual void reinitExpression(ExpiringPointer<ExpressionModelHandle> model);
virtual void editExpression(Ion::Events::Event event);
virtual bool editSelectedRecordWithText(const char * text);
virtual bool removeModelRow(Ion::Storage::Record record);

8
apps/shared/storage_expression_model_store.cpp
View File

@@ -15,14 +15,14 @@ Ion::Storage::Record StorageExpressionModelStore::recordAtIndex(int i) const {
return Ion::Storage::sharedStorage()->recordWithExtensionAtIndex(modelExtension(), i);
}
StorageExpressionModel * StorageExpressionModelStore::privateModelForRecord(Ion::Storage::Record record) const {
ExpressionModelHandle * StorageExpressionModelStore::privateModelForRecord(Ion::Storage::Record record) const {
for (int i = 0; i < k_maxNumberOfMemoizedModels; i++) {
if (!memoizedModelAtIndex(i)->isNull() && *memoizedModelAtIndex(i) == record) {
return memoizedModelAtIndex(i);
}
}
setMemoizedModelAtIndex(m_oldestMemoizedIndex, record);
StorageExpressionModel * result = memoizedModelAtIndex(m_oldestMemoizedIndex);
ExpressionModelHandle * result = memoizedModelAtIndex(m_oldestMemoizedIndex);
m_oldestMemoizedIndex = (m_oldestMemoizedIndex+1) % k_maxNumberOfMemoizedModels;
return result;
}
@@ -44,7 +44,7 @@ void StorageExpressionModelStore::tidy() {
int StorageExpressionModelStore::numberOfModelsSatisfyingTest(ModelTest test) const {
int result = 0;
int i = 0;
StorageExpressionModel * m = privateModelForRecord(recordAtIndex(i++));
ExpressionModelHandle * m = privateModelForRecord(recordAtIndex(i++));
while (!m->isNull()) {
if (test(m)) {
result++;
@@ -59,7 +59,7 @@ Ion::Storage::Record StorageExpressionModelStore::recordStatifyingTestAtIndex(in
int index = 0;
int currentModelIndex = 0;
Ion::Storage::Record r = recordAtIndex(currentModelIndex++);
StorageExpressionModel * m = privateModelForRecord(r);
ExpressionModelHandle * m = privateModelForRecord(r);
while (!m->isNull()) {
assert(currentModelIndex <= numberOfModels());
if (test(m)) {

14
apps/shared/storage_expression_model_store.h
View File

@@ -1,7 +1,7 @@
#ifndef SHARED_STORAGE_EXPRESSION_MODEL_STORE_H
#define SHARED_STORAGE_EXPRESSION_MODEL_STORE_H
#include "storage_expression_model.h"
#include "expression_model_handle.h"
#include "expiring_pointer.h"
#include <ion/storage.h>
#include <assert.h>
@@ -17,10 +17,10 @@ public:
// Getters
int numberOfModels() const;
int numberOfDefinedModels() const { return numberOfModelsSatisfyingTest([](StorageExpressionModel * m) { return m->isDefined(); }); }
int numberOfDefinedModels() const { return numberOfModelsSatisfyingTest([](ExpressionModelHandle * m) { return m->isDefined(); }); }
Ion::Storage::Record recordAtIndex(int i) const;
Ion::Storage::Record definedRecordAtIndex(int i) const { return recordStatifyingTestAtIndex(i, [](StorageExpressionModel * m) { return m->isDefined(); }); }
ExpiringPointer<StorageExpressionModel> modelForRecord(Ion::Storage::Record record) const { return ExpiringPointer<StorageExpressionModel>(privateModelForRecord(record)); }
Ion::Storage::Record definedRecordAtIndex(int i) const { return recordStatifyingTestAtIndex(i, [](ExpressionModelHandle * m) { return m->isDefined(); }); }
ExpiringPointer<ExpressionModelHandle> modelForRecord(Ion::Storage::Record record) const { return ExpiringPointer<ExpressionModelHandle>(privateModelForRecord(record)); }
// Add and Remove
virtual Ion::Storage::Record::ErrorStatus addEmptyModel() = 0;
@@ -32,14 +32,14 @@ public:
void storageDidChangeForRecord(const Ion::Storage::Record record) const { resetMemoizedModelsExceptRecord(record); }
protected:
constexpr static int k_maxNumberOfMemoizedModels = 10;
typedef bool (*ModelTest)(StorageExpressionModel * model);
typedef bool (*ModelTest)(ExpressionModelHandle * model);
int numberOfModelsSatisfyingTest(ModelTest test) const;
Ion::Storage::Record recordStatifyingTestAtIndex(int i, ModelTest test) const;
StorageExpressionModel * privateModelForRecord(Ion::Storage::Record record) const;
ExpressionModelHandle * privateModelForRecord(Ion::Storage::Record record) const;
private:
void resetMemoizedModelsExceptRecord(const Ion::Storage::Record record = Ion::Storage::Record()) const;
virtual void setMemoizedModelAtIndex(int cacheIndex, Ion::Storage::Record) const = 0;
virtual StorageExpressionModel * memoizedModelAtIndex(int cacheIndex) const = 0;
virtual ExpressionModelHandle * memoizedModelAtIndex(int cacheIndex) const = 0;
virtual const char * modelExtension() const = 0;
/* Memoization of k_maxNumberOfMemoizedModels. When the required model is not
* present, we override the m_oldestMemoizedIndex model. This actually

6
apps/shared/storage_function.h
View File

@@ -2,11 +2,11 @@
#define SHARED_STORAGE_FUNCTION_H
#include <poincare/function.h>
#include "storage_expression_model.h"
#include "expression_model_handle.h"
namespace Shared {
class StorageFunction : public StorageExpressionModel {
class StorageFunction : public ExpressionModelHandle {
public:
enum class NameNotCompliantError {
None = 0,
@@ -20,7 +20,7 @@ public:
static bool BaseNameCompliant(const char * baseName, NameNotCompliantError * error = nullptr);
// Constructors
StorageFunction(Ion::Storage::Record record) : StorageExpressionModel(record){}
StorageFunction(Ion::Storage::Record record) : ExpressionModelHandle(record){}
// Properties
bool isActive() const;

4
apps/shared/storage_function_store.h
View File

@@ -14,8 +14,8 @@ public:
StorageFunctionStore() : StorageExpressionModelStore() {}
uint32_t storeChecksum();
// An active function must be defined to be counted
int numberOfActiveFunctions() const { return numberOfModelsSatisfyingTest([](StorageExpressionModel * m) { return m->isDefined() && static_cast<StorageFunction *>(m)->isActive(); }); }
Ion::Storage::Record activeRecordAtIndex(int i) const { return recordStatifyingTestAtIndex(i, [](StorageExpressionModel * m) { return m->isDefined() && static_cast<StorageFunction *>(m)->isActive(); }); }
int numberOfActiveFunctions() const { return numberOfModelsSatisfyingTest([](ExpressionModelHandle * m) { return m->isDefined() && static_cast<StorageFunction *>(m)->isActive(); }); }
Ion::Storage::Record activeRecordAtIndex(int i) const { return recordStatifyingTestAtIndex(i, [](ExpressionModelHandle * m) { return m->isDefined() && static_cast<StorageFunction *>(m)->isActive(); }); }
ExpiringPointer<StorageFunction> modelForRecord(Ion::Storage::Record record) const { return ExpiringPointer<StorageFunction>(static_cast<StorageFunction *>(privateModelForRecord(record))); }