[poincare] Create a ContextWithParent that implements expressionTypeForIdentifier

apps/regression/app.cpp

@@ -1,5 +1,6 @@
 #include "app.h"
 #include "regression_icon.h"
+#include "../apps_container.h"
 #include <apps/i18n.h>
 
 using namespace Shared;
@@ -29,7 +30,7 @@ App::Snapshot::Snapshot() :
 }
 
 App * App::Snapshot::unpack(Container * container) {
-  return new (container->currentAppBuffer()) App(this);
+  return new (container->currentAppBuffer()) App(this, static_cast<AppsContainer *>(container)->globalContext());
 }
 
 void App::Snapshot::reset() {
@@ -49,7 +50,7 @@ void App::Snapshot::tidy() {
   m_store.tidy();
 }
 
-App::App(Snapshot * snapshot) :
+App::App(Snapshot * snapshot, Poincare::Context * parentContext) :
   TextFieldDelegateApp(snapshot, &m_tabViewController),
   m_calculationController(&m_calculationAlternateEmptyViewController, &m_calculationHeader, snapshot->store()),
   m_calculationAlternateEmptyViewController(&m_calculationHeader, &m_calculationController, &m_calculationController),
@@ -58,7 +59,7 @@ App::App(Snapshot * snapshot) :
   m_graphAlternateEmptyViewController(&m_graphHeader, &m_graphController, &m_graphController),
   m_graphHeader(&m_graphStackViewController, &m_graphAlternateEmptyViewController, &m_graphController),
   m_graphStackViewController(&m_tabViewController, &m_graphHeader),
-  m_storeController(&m_storeHeader, this, snapshot->store(), &m_storeHeader),
+  m_storeController(&m_storeHeader, this, snapshot->store(), &m_storeHeader, parentContext),
   m_storeHeader(&m_storeStackViewController, &m_storeController, &m_storeController),
   m_storeStackViewController(&m_tabViewController, &m_storeHeader),
   m_tabViewController(&m_modalViewController, snapshot, &m_storeStackViewController, &m_graphStackViewController, &m_calculationHeader),

apps/regression/app.h

@@ -45,7 +45,7 @@ public:
   }
   RegressionController * regressionController() { return &m_regressionController; }
 private:
-  App(Snapshot * snapshot);
+  App(Snapshot * snapshot, Poincare::Context * parentContext);
   CalculationController m_calculationController;
   AlternateEmptyViewController m_calculationAlternateEmptyViewController;
   ButtonRowController m_calculationHeader;

apps/regression/regression_context.cpp

@@ -24,7 +24,7 @@ const Expression RegressionContext::expressionForSymbolAbstract(const SymbolAbst
     assert(m_seriesPairIndex < m_store->numberOfPairsOfSeries(series));
     return Float<double>::Builder(m_store->get(series, storeI, m_seriesPairIndex));
   } else {
-    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
+    return ContextWithParent::expressionForSymbolAbstract(symbol, clone);
   }
 }
 

apps/regression/store_controller.cpp

@@ -10,19 +10,14 @@ using namespace Shared;
 
 namespace Regression {
 
-StoreController::StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header) :
+StoreController::StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header, Context * parentContext) :
   Shared::StoreController(parentResponder, inputEventHandlerDelegate, store, header),
   m_titleCells{},
-  m_regressionContext(store),
+  m_regressionContext(store, parentContext),
   m_storeParameterController(this, store, this)
 {
 }
 
-StoreContext * StoreController::storeContext() {
-  m_regressionContext.setParentContext(AppsContainer::sharedAppsContainer()->globalContext());
-  return &m_regressionContext;
-}
-
 void StoreController::setFormulaLabel() {
   int series = selectedColumn() / Store::k_numberOfColumnsPerSeries;
   int isXColumn = selectedColumn() % Store::k_numberOfColumnsPerSeries == 0;

apps/regression/store_controller.h

@@ -12,8 +12,8 @@ namespace Regression {
 
 class StoreController : public Shared::StoreController {
 public:
-  StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header);
-  Shared::StoreContext * storeContext() override;
+  StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header, Poincare::Context * parentContext);
+  Shared::StoreContext * storeContext() override { return &m_regressionContext; }
   void setFormulaLabel() override;
   bool fillColumnWithFormula(Poincare::Expression formula) override;
   void willDisplayCellAtLocation(HighlightCell * cell, int i, int j) override;

apps/sequence/cache_context.cpp

@@ -8,8 +8,8 @@ namespace Sequence {
 
 template<typename T>
 CacheContext<T>::CacheContext(Context * parentContext) :
-  m_values{{NAN, NAN},{NAN, NAN},{NAN,NAN}},
-  m_parentContext(parentContext)
+  ContextWithParent(parentContext),
+  m_values{{NAN, NAN},{NAN, NAN},{NAN,NAN}}
 {
 }
 
@@ -24,12 +24,7 @@ const Expression CacheContext<T>::expressionForSymbolAbstract(const SymbolAbstra
     Symbol s = const_cast<Symbol &>(static_cast<const Symbol &>(symbol));
     return Float<T>::Builder(m_values[nameIndexForSymbol(s)][rankIndexForSymbol(s)]);
   }
-  return m_parentContext->expressionForSymbolAbstract(symbol, clone);
-}
-
-template<typename T>
-void CacheContext<T>::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol) {
-  m_parentContext->setExpressionForSymbolAbstract(expression, symbol);
+  return ContextWithParent::expressionForSymbolAbstract(symbol, clone);
 }
 
 template<typename T>

apps/sequence/cache_context.h

@@ -9,17 +9,15 @@
 namespace Sequence {
 
 template<typename T>
-class CacheContext : public Poincare::Context {
+class CacheContext : public Poincare::ContextWithParent {
 public:
   CacheContext(Poincare::Context * parentContext);
   const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
-  void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol) override;
   void setValueForSymbol(T value, const Poincare::Symbol & symbol);
 private:
   int nameIndexForSymbol(const Poincare::Symbol & symbol);
   int rankIndexForSymbol(const Poincare::Symbol & symbol);
   T m_values[MaxNumberOfSequences][MaxRecurrenceDepth];
-  Context * m_parentContext;
 };
 
 }

apps/sequence/sequence_context.h

@@ -1,7 +1,7 @@
 #ifndef SEQUENCE_SEQUENCE_CONTEXT_H
 #define SEQUENCE_SEQUENCE_CONTEXT_H
 
-#include <poincare/context.h>
+#include <poincare/context_with_parent.h>
 #include <poincare/expression.h>
 #include <poincare/symbol.h>
 
@@ -33,24 +33,17 @@ private:
   T m_values[MaxNumberOfSequences][MaxRecurrenceDepth+1];
 };
 
-class SequenceContext : public Poincare::Context {
+class SequenceContext : public Poincare::ContextWithParent {
 public:
   SequenceContext(Poincare::Context * parentContext, SequenceStore * sequenceStore) :
-    Context(),
+    ContextWithParent(parentContext),
     m_floatSequenceContext(),
     m_doubleSequenceContext(),
-    m_sequenceStore(sequenceStore),
-    m_parentContext(parentContext) {}
+    m_sequenceStore(sequenceStore) {}
   /* expressionForSymbolAbstract & setExpressionForSymbolAbstractName directly call the parent
    * context respective methods. Indeed, special chars like n, u(n), u(n+1),
    * v(n), v(n+1) are taken into accound only when evaluating sequences which
    * is done in another context. */
-  const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override {
-    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
-  }
-  void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol) override {
-    m_parentContext->setExpressionForSymbolAbstract(expression, symbol);
-  }
   template<typename T> T valueOfSequenceAtPreviousRank(int sequenceIndex, int rank) const {
     if (sizeof(T) == sizeof(float)) {
       return m_floatSequenceContext.valueOfSequenceAtPreviousRank(sequenceIndex, rank);
@@ -71,7 +64,6 @@ private:
   TemplatedSequenceContext<float> m_floatSequenceContext;
   TemplatedSequenceContext<double> m_doubleSequenceContext;
   SequenceStore * m_sequenceStore;
-  Poincare::Context * m_parentContext;
 };
 
 }

apps/shared/Makefile

@@ -11,7 +11,6 @@ app_shared_test_src = $(addprefix apps/shared/,\
   interactive_curve_view_range.cpp \
   memoized_curve_view_range.cpp \
   range_1D.cpp \
-  store_context.cpp \
 )
 
 app_shared_src = $(addprefix apps/shared/,\

apps/shared/store_context.cpp

@@ -1,14 +0,0 @@
-#include "store_context.h"
-#include <poincare/decimal.h>
-#include <assert.h>
-#include <string.h>
-
-using namespace Poincare;
-
-namespace Shared {
-
-void StoreContext::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol) {
-  m_parentContext->setExpressionForSymbolAbstract(expression, symbol);
-}
-
-}

apps/shared/store_context.h

@@ -2,28 +2,24 @@
 #define SHARED_STORE_CONTEXT_H
 
 #include <poincare/expression.h>
-#include <poincare/context.h>
+#include <poincare/context_with_parent.h>
 #include <poincare/symbol.h>
 #include "double_pair_store.h"
 #include <cmath>
 
 namespace Shared {
 
-class StoreContext : public Poincare::Context {
+class StoreContext : public Poincare::ContextWithParent {
 public:
-  StoreContext(Shared::DoublePairStore * store) :
-    Poincare::Context(),
+  StoreContext(Shared::DoublePairStore * store, Context * parentContext) :
+    Poincare::ContextWithParent(parentContext),
     m_store(store),
-    m_seriesPairIndex(-1),
-    m_parentContext(nullptr)
+    m_seriesPairIndex(-1)
   {}
-  void setParentContext(Poincare::Context * parentContext) { m_parentContext = parentContext; }
   void setSeriesPairIndex(int j) { m_seriesPairIndex = j; }
-  void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol) override;
 protected:
   Shared::DoublePairStore * m_store;
   int m_seriesPairIndex;
-  Poincare::Context * m_parentContext;
 };
 
 }

apps/statistics/app.cpp

@@ -1,5 +1,6 @@
 #include "app.h"
 #include "stat_icon.h"
+#include "../apps_container.h"
 #include <apps/i18n.h>
 
 using namespace Shared;
@@ -31,7 +32,7 @@ App::Snapshot::Snapshot() :
 }
 
 App * App::Snapshot::unpack(Container * container) {
-  return new (container->currentAppBuffer()) App(this);
+  return new (container->currentAppBuffer()) App(this, static_cast<AppsContainer *>(container)->globalContext());
 }
 
 void App::Snapshot::reset() {
@@ -49,7 +50,7 @@ App::Descriptor * App::Snapshot::descriptor() {
   return &descriptor;
 }
 
-App::App(Snapshot * snapshot) :
+App::App(Snapshot * snapshot, Poincare::Context * parentContext) :
   TextFieldDelegateApp(snapshot, &m_tabViewController),
   m_calculationController(&m_calculationAlternateEmptyViewController, &m_calculationHeader, snapshot->store()),
   m_calculationAlternateEmptyViewController(&m_calculationHeader, &m_calculationController, &m_calculationController),
@@ -61,7 +62,7 @@ App::App(Snapshot * snapshot) :
   m_histogramAlternateEmptyViewController(&m_histogramHeader, &m_histogramController, &m_histogramController),
   m_histogramHeader(&m_histogramStackViewController, &m_histogramAlternateEmptyViewController, &m_histogramController),
   m_histogramStackViewController(&m_tabViewController, &m_histogramHeader),
-  m_storeController(&m_storeHeader, this, snapshot->store(), &m_storeHeader),
+  m_storeController(&m_storeHeader, this, snapshot->store(), &m_storeHeader, parentContext),
   m_storeHeader(&m_storeStackViewController, &m_storeController, &m_storeController),
   m_storeStackViewController(&m_tabViewController, &m_storeHeader),
   m_tabViewController(&m_modalViewController, snapshot, &m_storeStackViewController, &m_histogramStackViewController, &m_boxHeader, &m_calculationHeader)

apps/statistics/app.h

@@ -44,7 +44,7 @@ public:
     BoxView::Quantile m_selectedBoxQuantile;
   };
 private:
-  App(Snapshot * snapshot);
+  App(Snapshot * snapshot, Poincare::Context * parentContext);
   CalculationController m_calculationController;
   AlternateEmptyViewController m_calculationAlternateEmptyViewController;
   ButtonRowController m_calculationHeader;

apps/statistics/statistics_context.cpp

@@ -24,7 +24,7 @@ const Expression StatisticsContext::expressionForSymbolAbstract(const SymbolAbst
     assert(m_seriesPairIndex < m_store->numberOfPairsOfSeries(series));
     return Float<double>::Builder(m_store->get(series, storeI, m_seriesPairIndex));
   } else {
-    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
+    return ContextWithParent::expressionForSymbolAbstract(symbol, clone);
   }
 }
 

apps/statistics/store_controller.cpp

@@ -12,20 +12,15 @@ using namespace Shared;
 
 namespace Statistics {
 
-StoreController::StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header) :
+StoreController::StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header, Context * parentContext) :
   Shared::StoreController(parentResponder, inputEventHandlerDelegate, store, header),
   m_titleCells{},
   m_store(store),
-  m_statisticsContext(m_store),
+  m_statisticsContext(m_store, parentContext),
   m_storeParameterController(this, store, this)
 {
 }
 
-StoreContext * StoreController::storeContext() {
-  m_statisticsContext.setParentContext(AppsContainer::sharedAppsContainer()->globalContext());
-  return &m_statisticsContext;
-}
-
 void StoreController::setFormulaLabel() {
   int series = selectedColumn() / Store::k_numberOfColumnsPerSeries;
   int isValueColumn = selectedColumn() % Store::k_numberOfColumnsPerSeries == 0;

apps/statistics/store_controller.h

@@ -11,8 +11,8 @@ namespace Statistics {
 
 class StoreController : public Shared::StoreController {
 public:
-  StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header);
-  Shared::StoreContext * storeContext() override;
+  StoreController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Store * store, ButtonRowController * header, Poincare::Context * parentContext);
+  Shared::StoreContext * storeContext() override { return &m_statisticsContext; }
   void setFormulaLabel() override;
   bool fillColumnWithFormula(Poincare::Expression formula) override;
   void willDisplayCellAtLocation(HighlightCell * cell, int i, int j) override;

poincare/include/poincare/context.h

@@ -16,7 +16,7 @@ public:
     Function,
     Symbol
   };
-  virtual SymbolAbstractType expressionTypeForIdentifier(const char * identifier, int length) { assert(false); return SymbolAbstractType::None; }
+  virtual SymbolAbstractType expressionTypeForIdentifier(const char * identifier, int length) = 0;
   virtual const Expression expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) = 0;
   virtual void setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol) = 0;
 };

poincare/include/poincare/context_with_parent.h

@@ -0,0 +1,24 @@
+#ifndef POINCARE_CONTEXT_WITH_PARENT_H
+#define POINCARE_CONTEXT_WITH_PARENT_H
+
+#include <poincare/context.h>
+#include <poincare/expression.h>
+#include <assert.h>
+
+namespace Poincare {
+
+class ContextWithParent : public Context {
+public:
+  ContextWithParent(Context * parentContext) : m_parentContext(parentContext) { assert(parentContext); }
+
+  // Context
+  SymbolAbstractType expressionTypeForIdentifier(const char * identifier, int length) override { return m_parentContext->expressionTypeForIdentifier(identifier, length); }
+  void setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol) override { m_parentContext->setExpressionForSymbolAbstract(expression, symbol); }
+  const Expression expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) override { return m_parentContext->expressionForSymbolAbstract(symbol, clone); }
+private:
+  Context * m_parentContext;
+};
+
+}
+
+#endif

poincare/include/poincare/variable_context.h

@@ -1,14 +1,14 @@
 #ifndef POINCARE_VARIABLE_CONTEXT_H
 #define POINCARE_VARIABLE_CONTEXT_H
 
-#include <poincare/context.h>
+#include <poincare/context_with_parent.h>
 #include <poincare/float.h>
 
 namespace Poincare {
 
-class VariableContext : public Context {
+class VariableContext : public ContextWithParent {
 public:
-  VariableContext(const char * name, Context * parentContext = nullptr);
+  VariableContext(const char * name, Context * parentContext);
   template<typename T>
   void setApproximationForVariable(T value);
 
@@ -19,7 +19,6 @@ public:
 private:
   const char * m_name;
   Expression m_value;
-  Context * m_parentContext;
 };
 
 }

poincare/src/variable_context.cpp

@@ -8,9 +8,9 @@
 namespace Poincare {
 
 VariableContext::VariableContext(const char * name, Context * parentContext) :
+  ContextWithParent(parentContext),
   m_name(name),
-  m_value(),
-  m_parentContext(parentContext)
+  m_value()
 {
 }
 
@@ -27,7 +27,7 @@ void VariableContext::setExpressionForSymbolAbstract(const Expression & expressi
     }
     m_value = expression.clone();
   } else {
-    m_parentContext->setExpressionForSymbolAbstract(expression, symbol);
+    return ContextWithParent::setExpressionForSymbolAbstract(expression, symbol);
   }
 }
 
@@ -38,7 +38,7 @@ const Expression VariableContext::expressionForSymbolAbstract(const SymbolAbstra
     }
     return Undefined::Builder();
   } else {
-    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
+    return ContextWithParent::expressionForSymbolAbstract(symbol, clone);
   }
 }