godleyTable.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 GODLEYTABLE_H
#define GODLEYTABLE_H

#include <set>
#include <vector>

#include <ecolab.h>

#include "variable.h"
#include "assetClass.h"

namespace minsky
{
  using namespace std;
  using classdesc::shared_ptr;

  class GodleyTable: public GodleyAssetClass
  {
  public:

    friend struct SchemaHelper;
    friend class GodleyIcon;
    typedef std::vector<std::vector<string>> Data;
  private:
    CLASSDESC_ACCESS(GodleyTable);
    vector<AssetClass> m_assetClass{noAssetClass, asset, liability, equity};
    Data data;

    static void markEdited(); 
    void _resize(unsigned rows, unsigned cols) {
      // resize existing
      for (std::size_t i=0; i<data.size(); ++i) data[i].resize(cols);
      data.resize(rows, vector<string>(cols));
      m_assetClass.resize(cols, noAssetClass);
    }
  public:
    typedef GodleyAssetClass::AssetClass AssetClass;
    
    bool doubleEntryCompliant;

    std::string title;
  
    static const char* initialConditions;
    GodleyTable(): doubleEntryCompliant(true)
    {
      _resize(2,4);
      cell(1,0)=initialConditions;
      
    }
    
    // Perform deep comparison of Godley tables in history to avoid spurious noAssetClass columns from arising during undo. For ticket 1118.
    bool operator==(const GodleyTable& other) const 
    {
                return (data==other.data && m_assetClass==other.m_assetClass &&
                 doubleEntryCompliant==other.doubleEntryCompliant && title==other.title);
    }    

    const vector<AssetClass>& _assetClass() const {return m_assetClass;}
    AssetClass _assetClass(std::size_t col) const;
    AssetClass _assetClass(std::size_t col, AssetClass cls);
    
    bool singleEquity() const;

    void nameUnique();

    bool signConventionReversed(int col) const
    {
      return doubleEntryCompliant && 
        (_assetClass(col)==liability || _assetClass(col)==equity);
    }
    string assetClass(ecolab::TCL_args args); 
  
    bool initialConditionRow(unsigned row) const;
    
    bool singularRow(unsigned row, unsigned col);
    
    std::size_t rows() const {return data.size();}
    std::size_t cols() const {return data.empty()? 0: data[0].size();}

    void clear() {data.clear(); m_assetClass.clear(); markEdited();}
    void resize(unsigned rows, unsigned cols){_resize(rows,cols); markEdited();}

    void insertRow(unsigned row);
    void deleteRow(unsigned row) {data.erase(data.begin()+row);}
    void insertCol(unsigned col);
    void deleteCol(unsigned col);
    void moveRow(int row, int n);
    void moveCol(int col, int n);

    void dimension(unsigned rows, unsigned cols) {clear(); resize(rows,cols);}

    string& cell(unsigned row, unsigned col) {
      if (row>=rows() || col>=cols())
        _resize(row+1, col+1);
      if (data[row].size()<=col) data[row].resize(cols());
      return data[row][col];
    }
    const string& cell(unsigned row, unsigned col) const {
      if (row>=data.size() || col>=data[row].size())
        throw std::out_of_range("Godley table index error");
      return data[row][col];
    }
    bool cellInTable(int row, int col) const
    {return row>=0 && std::size_t(row)<rows() && col>=0 && std::size_t(col)<cols();}
    string getCell(unsigned row, unsigned col) const {
      if (row<rows() && col<cols())
        return cell(row,col);
      else
        return "";
    }
    void setCell(unsigned row, unsigned col, const string& data) {
      cell(row,col)=data;
    }

    void balanceEquity(int col);
    
    std::vector<std::string> getColumnVariables() const;
    std::vector<std::string> getVariables() const;
    std::string savedText;

    std::vector<std::string> getColumn(unsigned col) const;
    
    void setDEmode(bool doubleEntryCompliant);

    std::map<std::string,double> rowSumAsMap(int row) const;
    static std::string stringify(const std::map<std::string,double>&);
    
    std::string rowSum(int row) const {return stringify(rowSumAsMap(row));}

    const Data& getData() const {return data;}

    void exportToLaTeX(const std::string& filename) const;
    void exportToCSV(const std::string& filename) const;

    void orderAssetClasses();

    void rename(const std::string& from, const std::string& to);
    void renameFlows(const std::string& from, const std::string& to);        
    void renameStock(const std::string& from, const std::string& to);        
  };

}

#include "godleyTable.cd"
#include "godleyTable.xcd"
#endif