variable.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2012
  @author Russell Standish
  This file is part of Minsky.

  Minsky is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  Minsky is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with Minsky.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef VARIABLE_H
#define VARIABLE_H

#include "slider.h"
#include "str.h"
#include "CSVParser.h"

#include <ecolab.h>
#include <arrays.h>

#include <vector>
#include <map>
// override EcoLab's default CLASSDESC_ACCESS macro
#include "classdesc_access.h"

#include "engNotation.h"

#include "polyBase.h"
#include <polyPackBase.h>
#include "variableType.h"
#include "itemT.h"
#include <accessor.h>
#include <cairo/cairo.h>

namespace ecolab {
  class Pango;
  class Plot;
}

namespace minsky
{
  class VariablePtr;
  struct SchemaHelper;
  class GodleyIcon;
  class RenderVariable;
  
  struct IncrDecrCounter
  {
    int& ctr;
    IncrDecrCounter(int& ctr): ctr(ctr) {++ctr;}
    ~IncrDecrCounter() {--ctr;}
  };

  namespace VarAccessors
  {
    // constructors defined below once member functions available
    struct NameAccessor: ecolab::TCLAccessor<minsky::VariableBase,std::string,0> {NameAccessor();};
    struct InitAccessor: ecolab::TCLAccessor<minsky::VariableBase,std::string,1> {InitAccessor();};
    struct ValueAccessor: ecolab::TCLAccessor<minsky::VariableBase,double> {ValueAccessor();};
  }

  class VariableCaches
  {
  CLASSDESC_ACCESS(VariableCaches);
  protected:
    mutable classdesc::Exclude<std::shared_ptr<RenderVariable>> cachedNameRender;
    mutable classdesc::Exclude<std::shared_ptr<ecolab::Pango>> cachedMantissa;
    mutable classdesc::Exclude<std::shared_ptr<ecolab::Pango>> cachedExponent;
    mutable double cachedValue, cachedTime;
  public:
    VariableCaches()=default;
    VariableCaches(const VariableCaches&) {}
    VariableCaches& operator=(const VariableCaches&) {return *this;}
  };
  
  class VariableBase: virtual public classdesc::PolyPackBase,
                      public BottomRightResizerItem,
                      public VariableType,
                      public VarAccessors::NameAccessor,
                      public VarAccessors::InitAccessor,
                      public VarAccessors::ValueAccessor,
                      public VariableCaches
  {
  public:
    typedef VariableType::Type Type;
    friend struct minsky::SchemaHelper;

  private:
    CLASSDESC_ACCESS(VariableBase);
    std::string m_name;
    std::string m_canonicalName; 
    std::pair<std::string,std::string> m_dimLabelsPicked;    
    mutable int unitsCtr=0; 
    static int stockVarsPassed; 

    void insertControlled(Selection& selection) override;

    classdesc::Exclude<std::shared_ptr<ecolab::Plot>> miniPlot;
    
  protected:
    void addPorts();
    
  public:
    static int varsPassed; 
    static VariableBase* create(Type type); 

    virtual std::size_t numPorts() const=0;
    virtual Type type() const=0;

    void retype(VariableType::Type type);

    
    classdesc::Exclude<std::weak_ptr<Item>> controller;
    bool visible() const override;

    const VariableBase* variableCast() const override {return this;}
    VariableBase* variableCast() override {return this;}

    float zoomFactor() const override;

    bool local() const;
    void toggleLocal() {name(m_name[0]==':'? m_name.substr(1): ':'+m_name);}
    
    virtual std::string name() const;
    virtual std::string name(const std::string& nm);
    const std::string& canonicalName() const {return m_canonicalName;}

    const std::string& rawName() const {return m_name;}
    
    bool ioVar() const override;
    
    void ensureValueExists(VariableValue* vv, const std::string& name) const;

    virtual std::string valueId() const;
    std::string valueIdInCurrentScope(const std::string& nm) const;
    std::shared_ptr<VariableValue> vValue() const;
    std::vector<unsigned> dims() const;
    std::vector<std::string> dimLabels() const;
        
    std::pair<std::string,std::string> getDimLabelsPicked() const {return m_dimLabelsPicked;}   
    std::pair<std::string,std::string> setDimLabelsPicked(const std::string& dimLabel1, const std::string& dimLabel2) {
      m_dimLabelsPicked=std::make_pair(dimLabel1,dimLabel2);
      return m_dimLabelsPicked;
    }         

    std::string init() const; 
    std::string init(const std::string&); 
    
    virtual double value(const double&);
    virtual double value() const override;  

    const std::string& detailedText() const override;
    const std::string& detailedText(const std::string& x) override;
    const std::string& tooltip() const override;
    const std::string& tooltip(const std::string& x) override;

    bool sliderVisible() const;
    
    Units units(bool check) const override;
    Units units() const {return units(false);}
    void setUnits(const std::string&) const;
    std::string unitsStr() const {return units().str();}
    
    bool onKeyPress(int, const std::string&, int) override; 
    
    bool lhs() const {return type()==flow || type()==tempFlow;} 
    bool temp() const {return type()==tempFlow || type()==undefined;}
    virtual VariableBase* clone() const override=0;
    bool isStock() const {return type()==stock || type()==integral;}

    std::string definition() const;

    void draw(cairo_t*) const override;  
    void resize(const LassoBox& b) override;
    ClickType::Type clickType(float x, float y) const override;

    bool defined() const {return inputWired() || (isStock() && controller.lock());}
    
    bool inputWired() const;
    
    std::vector<std::string> accessibleVars() const;

    EngNotation engExp() const
    {return minsky::engExp(value());}
    std::string mantissa(const EngNotation& e, int digits=3) const
    {return minsky::mantissa(value(),e, digits);}

    void exportAsCSV(const std::string& filename, bool tabular) const;
    void importFromCSV(const std::vector<std::string>& filenames,
                       const DataSpecSchema& spec) const;

    void destroyFrame() override;

    bool miniPlotEnabled() const {return bool(miniPlot);}
    bool miniPlotEnabled(bool);
    void resetMiniPlot();
    
    bool onMouseMotion(float x, float y) override;

    void adjustSliderBounds();
    
    double sliderMin() const;
    double sliderMin(double) const;
    double sliderMax() const;
    double sliderMax(double) const;
    double sliderStep() const;
    double sliderStep(double) const;
    bool sliderStepRel() const;
    bool sliderStepRel(bool) const;
    bool enableSlider() const;
    bool enableSlider(bool);
  };

  template <minsky::VariableType::Type T>
  class Variable: public ItemT<Variable<T>, VariableBase>,
                  public classdesc::PolyPack<Variable<T> >
  {
  public:
    typedef VariableBase::Type Type;
    Type type() const override {return T;}
    std::size_t numPorts() const override;

    Variable(const Variable& x): ItemT<Variable<T>, VariableBase>(x) {this->addPorts();}
    Variable& operator=(const Variable& x) {
      VariableBase::operator=(x);
      this->controller.reset(); // copy is not controlled by same object
      this->addPorts();
      return *this;
    }
    Variable(Variable&& x): ItemT<Variable<T>, VariableBase>(x) {this->addPorts();}
    Variable& operator=(Variable&& x) {
      VariableBase::operator=(x);
      this->addPorts();
      return *this;
    }
    Variable(const std::string& name="") {VariableBase::name(name); this->addPorts();}
    std::string classType() const override 
    {return "Variable:"+VariableType::typeName(type());}
    Variable* clone() const override {
      auto v=ItemT<Variable<T>, VariableBase>::clone();
      v->controller.reset(); // cloned variables are not controlled by this's controller
      // v is a Variable*, but C++ covariant return types rule prevent it being declared as such
      assert(dynamic_cast<Variable*>(v));
      return static_cast<Variable*>(v); 
    }
  };

  struct VarConstant: public Variable<VariableType::constant>
  {
    int id;
    static int nextId;
    VarConstant(): id(nextId++) {ensureValueExists(nullptr,"");}
    std::string valueId() const override {return "constant:"+str(id);}
    std::string name() const override {return init();}
    std::string name(const std::string& nm) override {ensureValueExists(nullptr,""); return name();}
    using VariableBase::value;
    double value(const double& x) override {init(str(x)); return x;}
    VarConstant* clone() const override {auto r=new VarConstant(*this); r->group.reset(); return r;}
    std::string classType() const override {return "VarConstant";}
    void TCL_obj(classdesc::TCL_obj_t& t, const classdesc::string& d) override 
    {::TCL_obj(t,d,*this);}
  };

  class VariablePtr: 
    public classdesc::shared_ptr<VariableBase>
  {
    typedef classdesc::shared_ptr<VariableBase> PtrBase;
  public:
    virtual int id() const {return -1;}
    VariablePtr(VariableBase::Type type=VariableBase::undefined, 
                const std::string& name=""): 
      PtrBase(VariableBase::create(type)) {get()->name(name);}
    virtual ~VariablePtr() {}
    template <class P>
    VariablePtr(P* var): PtrBase(dynamic_cast<VariableBase*>(var)) 
    {
      // check for incorrect type assignment
      assert(!var || *this);
    }
    VariablePtr(const classdesc::shared_ptr<VariableBase>& x): PtrBase(x) {}
    VariablePtr(const VariableBase& x): PtrBase(x.clone()) {}
    void retype(VariableBase::Type type);
    VariablePtr(const ItemPtr& x): 
      PtrBase(std::dynamic_pointer_cast<VariableBase>(x)) {}
    void makeConsistentWithValue();
  };
}

namespace classdesc
{
  template <> struct is_smart_ptr<minsky::VariablePtr>: public true_type {};
 }

#include "variable.cd"
#include "variable.xcd"
#endif