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 names:

Browse Source 
Sequence::DefinitionHandle --> Sequence::DefinitionModel
Sequence::FirstInitialConditionHandle -->
Sequence::FirstInitialConditionModel
Equation::Handle--> Equation::Model
This commit is contained in:
Émilie Feral
2019-03-11 18:11:03 +01:00
parent 57da4ea618
commit 5a5a181086
6 changed files with 63 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
apps/sequence/sequence.cpp
View File

@@ -15,12 +15,12 @@ using namespace Poincare;
namespace Sequence {
void Sequence::tidy() {
m_definitionHandle.tidyName();
m_definition.tidyName();
Function::tidy(); // m_definitionName.tidy()
m_firstInitialConditionHandle.tidy();
m_firstInitialConditionHandle.tidyName();
m_secondInitialConditionHandle.tidy();
m_secondInitialConditionHandle.tidyName();
m_firstInitialCondition.tidy();
m_firstInitialCondition.tidyName();
m_secondInitialCondition.tidy();
m_secondInitialCondition.tidyName();
m_nameLayout = Layout();
}
@@ -69,8 +69,8 @@ void Sequence::setType(Type t) {
void Sequence::setInitialRank(int rank) {
recordData()->setInitialRank(rank);
m_firstInitialConditionHandle.tidyName();
m_secondInitialConditionHandle.tidyName();
m_firstInitialCondition.tidyName();
m_secondInitialCondition.tidyName();
}
Poincare::Layout Sequence::nameLayout() {
@@ -193,14 +193,14 @@ Sequence::SequenceRecordData * Sequence::recordData() const {
/* Sequence Handle */
Poincare::Layout Sequence::SequenceHandle::name(Sequence * sequence) {
Poincare::Layout Sequence::SequenceModel::name(Sequence * sequence) {
if (m_name.isUninitialized()) {
buildName(sequence);
}
return m_name;
}
void Sequence::SequenceHandle::updateNewDataWithExpression(Ion::Storage::Record * record, Expression & expressionToStore, void * expressionAddress, size_t newExpressionSize, size_t previousExpressionSize) {
void Sequence::SequenceModel::updateNewDataWithExpression(Ion::Storage::Record * record, Expression & expressionToStore, void * expressionAddress, size_t newExpressionSize, size_t previousExpressionSize) {
Ion::Storage::Record::Data newData = record->value();
// Translate expressions located downstream
size_t sizeBeforeExpression = (char *)expressionAddress -(char *)newData.buffer;
@@ -216,17 +216,17 @@ void Sequence::SequenceHandle::updateNewDataWithExpression(Ion::Storage::Record
/* Definition Handle*/
void * Sequence::DefinitionHandle::expressionAddress(const Ion::Storage::Record * record) const {
void * Sequence::DefinitionModel::expressionAddress(const Ion::Storage::Record * record) const {
return (char *)record->value().buffer+sizeof(SequenceRecordData);
}
size_t Sequence::DefinitionHandle::expressionSize(const Ion::Storage::Record * record) const {
size_t Sequence::DefinitionModel::expressionSize(const Ion::Storage::Record * record) const {
Ion::Storage::Record::Data data = record->value();
SequenceRecordData * dataBuffer = static_cast<const Sequence *>(record)->recordData();
return data.size-sizeof(SequenceRecordData) - dataBuffer->firstInitialConditionSize() - dataBuffer->secondInitialConditionSize();
}
void Sequence::DefinitionHandle::buildName(Sequence * sequence) {
void Sequence::DefinitionModel::buildName(Sequence * sequence) {
char name = sequence->fullName()[0];
if (sequence->type() == Type::Explicit) {
m_name = HorizontalLayout::Builder(
@@ -246,22 +246,22 @@ void Sequence::DefinitionHandle::buildName(Sequence * sequence) {
/* First Initial Condition Handle*/
void * Sequence::FirstInitialConditionHandle::expressionAddress(const Ion::Storage::Record * record) const {
void * Sequence::FirstInitialConditionModel::expressionAddress(const Ion::Storage::Record * record) const {
Ion::Storage::Record::Data data = record->value();
SequenceRecordData * dataBuffer = static_cast<const Sequence *>(record)->recordData();
size_t offset = data.size - dataBuffer->firstInitialConditionSize() - dataBuffer->secondInitialConditionSize();
return (char *)data.buffer+offset;
}
size_t Sequence::FirstInitialConditionHandle::expressionSize(const Ion::Storage::Record * record) const {
size_t Sequence::FirstInitialConditionModel::expressionSize(const Ion::Storage::Record * record) const {
return static_cast<const Sequence *>(record)->recordData()->firstInitialConditionSize();
}
void Sequence::FirstInitialConditionHandle::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
void Sequence::FirstInitialConditionModel::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
static_cast<const Sequence *>(record)->recordData()->setFirstInitialConditionSize(newSize);
}
void Sequence::FirstInitialConditionHandle::buildName(Sequence * sequence) {
void Sequence::FirstInitialConditionModel::buildName(Sequence * sequence) {
assert(sequence->type() == Type::SingleRecurrence || sequence->type() == Type::DoubleRecurrence);
char buffer[k_initialRankNumberOfDigits+1];
Integer(sequence->initialRank()).serialize(buffer, k_initialRankNumberOfDigits+1);
@@ -273,22 +273,22 @@ void Sequence::FirstInitialConditionHandle::buildName(Sequence * sequence) {
/* Second Initial Condition Handle*/
void * Sequence::SecondInitialConditionHandle::expressionAddress(const Ion::Storage::Record * record) const {
void * Sequence::SecondInitialConditionModel::expressionAddress(const Ion::Storage::Record * record) const {
Ion::Storage::Record::Data data = record->value();
SequenceRecordData * dataBuffer = static_cast<const Sequence *>(record)->recordData();
size_t offset = data.size - dataBuffer->secondInitialConditionSize();
return (char *)data.buffer+offset;
}
void Sequence::SecondInitialConditionHandle::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
void Sequence::SecondInitialConditionModel::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
static_cast<const Sequence *>(record)->recordData()->setSecondInitialConditionSize(newSize);
}
size_t Sequence::SecondInitialConditionHandle::expressionSize(const Ion::Storage::Record * record) const {
size_t Sequence::SecondInitialConditionModel::expressionSize(const Ion::Storage::Record * record) const {
return static_cast<const Sequence *>(record)->recordData()->secondInitialConditionSize();
}
void Sequence::SecondInitialConditionHandle::buildName(Sequence * sequence) {
void Sequence::SecondInitialConditionModel::buildName(Sequence * sequence) {
assert(sequence->type() == Type::DoubleRecurrence);
char buffer[k_initialRankNumberOfDigits+1];
Integer(sequence->initialRank()+1).serialize(buffer, k_initialRankNumberOfDigits+1);

46
apps/sequence/sequence.h
View File

@@ -31,22 +31,22 @@ public:
void setType(Type type);
void setInitialRank(int rank);
// Definition
Poincare::Layout definitionName() { return m_definitionHandle.name(this); }
Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableHandle()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownN); }
Poincare::Layout definitionName() { return m_definition.name(this); }
Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableModel()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownN); }
// First initial condition
Poincare::Layout firstInitialConditionName() { return m_firstInitialConditionHandle.name(this); }
void firstInitialConditionText(char * buffer, size_t bufferSize) const { return m_firstInitialConditionHandle.text(this, buffer, bufferSize); }
Poincare::Expression firstInitialConditionExpressionReduced(Poincare::Context * context) const { return m_firstInitialConditionHandle.expressionReduced(this, context); }
Poincare::Expression firstInitialConditionExpressionClone() const { return m_firstInitialConditionHandle.expressionClone(this); }
Poincare::Layout firstInitialConditionLayout() { return m_firstInitialConditionHandle.layout(this); }
Ion::Storage::Record::ErrorStatus setFirstInitialConditionContent(const char * c) { return m_firstInitialConditionHandle.setContent(this, c); }
Poincare::Layout firstInitialConditionName() { return m_firstInitialCondition.name(this); }
void firstInitialConditionText(char * buffer, size_t bufferSize) const { return m_firstInitialCondition.text(this, buffer, bufferSize); }
Poincare::Expression firstInitialConditionExpressionReduced(Poincare::Context * context) const { return m_firstInitialCondition.expressionReduced(this, context); }
Poincare::Expression firstInitialConditionExpressionClone() const { return m_firstInitialCondition.expressionClone(this); }
Poincare::Layout firstInitialConditionLayout() { return m_firstInitialCondition.layout(this); }
Ion::Storage::Record::ErrorStatus setFirstInitialConditionContent(const char * c) { return m_firstInitialCondition.setContent(this, c); }
// Second initial condition
Poincare::Layout secondInitialConditionName() { return m_secondInitialConditionHandle.name(this); }
void secondInitialConditionText(char * buffer, size_t bufferSize) const { return m_secondInitialConditionHandle.text(this, buffer, bufferSize); }
Poincare::Expression secondInitialConditionExpressionReduced(Poincare::Context * context) const { return m_secondInitialConditionHandle.expressionReduced(this, context); }
Poincare::Expression secondInitialConditionExpressionClone() const { return m_secondInitialConditionHandle.expressionClone(this); }
Poincare::Layout secondInitialConditionLayout() { return m_secondInitialConditionHandle.layout(this); }
Ion::Storage::Record::ErrorStatus setSecondInitialConditionContent(const char * c) { return m_secondInitialConditionHandle.setContent(this, c); }
Poincare::Layout secondInitialConditionName() { return m_secondInitialCondition.name(this); }
void secondInitialConditionText(char * buffer, size_t bufferSize) const { return m_secondInitialCondition.text(this, buffer, bufferSize); }
Poincare::Expression secondInitialConditionExpressionReduced(Poincare::Context * context) const { return m_secondInitialCondition.expressionReduced(this, context); }
Poincare::Expression secondInitialConditionExpressionClone() const { return m_secondInitialCondition.expressionClone(this); }
Poincare::Layout secondInitialConditionLayout() { return m_secondInitialCondition.layout(this); }
Ion::Storage::Record::ErrorStatus setSecondInitialConditionContent(const char * c) { return m_secondInitialCondition.setContent(this, c); }
// Sequence properties
int numberOfElements() { return (int)type() + 1; }
@@ -94,9 +94,9 @@ private:
uint16_t m_secondInitialConditionSize;
};
class SequenceHandle : public Shared::ExpressionModel {
class SequenceModel : public Shared::ExpressionModel {
public:
SequenceHandle() : Shared::ExpressionModel(), m_name() {}
SequenceModel() : Shared::ExpressionModel(), m_name() {}
void tidyName() { m_name = Poincare::Layout(); }
virtual Poincare::Layout name(Sequence * sequence);
protected:
@@ -107,7 +107,7 @@ private:
virtual void updateMetaData(const Ion::Storage::Record * record, size_t newSize) {}
};
class DefinitionHandle : public SequenceHandle {
class DefinitionModel : public SequenceModel {
public:
void * expressionAddress(const Ion::Storage::Record * record) const override;
private:
@@ -115,7 +115,7 @@ private:
void buildName(Sequence * sequence) override;
};
class FirstInitialConditionHandle : public SequenceHandle {
class FirstInitialConditionModel : public SequenceModel {
public:
void * expressionAddress(const Ion::Storage::Record * record) const override;
private:
@@ -124,7 +124,7 @@ private:
void buildName(Sequence * sequence) override;
};
class SecondInitialConditionHandle : public SequenceHandle {
class SecondInitialConditionModel : public SequenceModel {
public:
void * expressionAddress(const Ion::Storage::Record * record) const override;
private:
@@ -135,11 +135,11 @@ private:
template<typename T> T templatedApproximateAtAbscissa(T x, SequenceContext * sqctx) const;
size_t metaDataSize() const override { return sizeof(SequenceRecordData); }
const Shared::ExpressionModel * handle() const override { return &m_definitionHandle; }
const Shared::ExpressionModel * model() const override { return &m_definition; }
SequenceRecordData * recordData() const;
DefinitionHandle m_definitionHandle;
FirstInitialConditionHandle m_firstInitialConditionHandle;
SecondInitialConditionHandle m_secondInitialConditionHandle;
DefinitionModel m_definition;
FirstInitialConditionModel m_firstInitialCondition;
SecondInitialConditionModel m_secondInitialCondition;
Poincare::Layout m_nameLayout;
};

4
apps/shared/cartesian_function.h
View File

@@ -15,7 +15,7 @@ public:
CartesianFunction(Ion::Storage::Record record = Record()) :
Function(record)
{}
Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableHandle()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownX); }
Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableModel()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownX); }
// Derivative
bool displayDerivative() const;
@@ -52,7 +52,7 @@ private:
size_t expressionSize(const Ion::Storage::Record * record) const override;
};
size_t metaDataSize() const override { return sizeof(CartesianFunctionRecordData); }
const ExpressionModel * handle() const override { return &m_model; }
const ExpressionModel * model() const override { return &m_model; }
CartesianFunctionRecordData * recordData() const;
Model m_model;
};

20
apps/shared/expression_model_handle.h
View File

@@ -12,10 +12,10 @@ public:
ExpressionModelHandle(Ion::Storage::Record record = Ion::Storage::Record());
// Property
void text(char * buffer, size_t bufferSize) const { return handle()->text(this, buffer, bufferSize); }
Poincare::Expression expressionReduced(Poincare::Context * context) const { return handle()->expressionReduced(this, context); }
Poincare::Expression expressionClone() const { return handle()->expressionClone(this); }
Poincare::Layout layout() { return handle()->layout(this); }
void text(char * buffer, size_t bufferSize) const { return model()->text(this, buffer, bufferSize); }
Poincare::Expression expressionReduced(Poincare::Context * context) const { return model()->expressionReduced(this, context); }
Poincare::Expression expressionClone() const { return model()->expressionClone(this); }
Poincare::Layout layout() { return model()->layout(this); }
/* Here, isDefined is the exact contrary of isEmpty. However, for Sequence
* inheriting from ExpressionModelHandle, isEmpty and isDefined have not exactly
* opposite meaning. For instance, u(n+1)=u(n) & u(0) = ... is not empty and
@@ -28,13 +28,13 @@ public:
* ExpressionModel, tidy and tidyExpressionModel trigger the same
* behaviour but it is not true for its child classes (for example, in
* Sequence). */
virtual void tidy() { handle()->tidy(); }
virtual Ion::Storage::Record::ErrorStatus setContent(const char * c) { return editableHandle()->setContent(this, c); }
Ion::Storage::Record::ErrorStatus setExpressionContent(Poincare::Expression & e) { return editableHandle()->setExpressionContent(this, e); }
virtual void tidy() { model()->tidy(); }
virtual Ion::Storage::Record::ErrorStatus setContent(const char * c) { return editableModel()->setContent(this, c); }
Ion::Storage::Record::ErrorStatus setExpressionContent(Poincare::Expression & e) { return editableModel()->setExpressionContent(this, e); }
protected:
bool isCircularlyDefined(Poincare::Context * context) const { return handle()->isCircularlyDefined(this, context); }
ExpressionModel * editableHandle() { return const_cast<ExpressionModel *>(handle()); }
virtual const ExpressionModel * handle() const = 0;
bool isCircularlyDefined(Poincare::Context * context) const { return model()->isCircularlyDefined(this, context); }
ExpressionModel * editableModel() { return const_cast<ExpressionModel *>(model()); }
virtual const ExpressionModel * model() const = 0;
virtual size_t metaDataSize() const = 0;
};

8
apps/solver/equation.cpp
View File

@@ -21,7 +21,7 @@ bool Equation::containsIComplex(Context * context) const {
return expressionClone().recursivelyMatches([](const Expression e, Context & context, bool replaceSymbols) { return e.type() == ExpressionNode::Type::Constant && static_cast<const Constant &>(e).isIComplex(); }, *context, true);
}
Expression Equation::Handle::standardForm(const Storage::Record * record, Context * context) const {
Expression Equation::Model::standardForm(const Storage::Record * record, Context * context) const {
if (m_standardForm.isUninitialized()) {
const Expression e = expressionReduced(record, context);
if (e.type() == ExpressionNode::Type::Unreal) {
@@ -44,17 +44,17 @@ Expression Equation::Handle::standardForm(const Storage::Record * record, Contex
return m_standardForm;
}
void Equation::Handle::tidy() const {
void Equation::Model::tidy() const {
ExpressionModel::tidy();
// Free the pool of the m_standardForm
m_standardForm = Expression();
}
void * Equation::Handle::expressionAddress(const Ion::Storage::Record * record) const {
void * Equation::Model::expressionAddress(const Ion::Storage::Record * record) const {
return (char *)record->value().buffer;
}
size_t Equation::Handle::expressionSize(const Ion::Storage::Record * record) const {
size_t Equation::Model::expressionSize(const Ion::Storage::Record * record) const {
return record->value().size;
}

8
apps/solver/equation.h
View File

@@ -11,11 +11,11 @@ public:
bool shouldBeClearedBeforeRemove() override {
return false;
}
Poincare::Expression standardForm(Poincare::Context * context) const { return m_handle.standardForm(this, context); }
Poincare::Expression standardForm(Poincare::Context * context) const { return m_model.standardForm(this, context); }
bool containsIComplex(Poincare::Context * context) const;
private:
class Handle : public Shared::ExpressionModel {
class Model : public Shared::ExpressionModel {
public:
Poincare::Expression standardForm(const Ion::Storage::Record * record, Poincare::Context * context) const;
void tidy() const override;
@@ -25,8 +25,8 @@ private:
mutable Poincare::Expression m_standardForm;
};
size_t metaDataSize() const override { return 0; }
const Shared::ExpressionModel * handle() const override { return &m_handle; }
Handle m_handle;
const Shared::ExpressionModel * model() const override { return &m_model; }
Model m_model;
};
}