typescriptAPI.cc File Reference

#include "function.h"
#include "typescriptAPI_base.h"
#include "minsky.h"
#include "minsky.tcd"
#include "assetClass.tcd"
#include "bookmark.h"
#include "bookmark.tcd"
#include "cairoSurfaceImage.tcd"
#include "callableFunction.tcd"
#include "canvas.tcd"
#include "CSVDialog.tcd"
#include "CSVParser.tcd"
#include "constMap.tcd"
#include "dataSpecSchema.tcd"
#include "dataOp.h"
#include "dataOp.tcd"
#include "dimension.tcd"
#include "engNotation.tcd"
#include "equationDisplay.tcd"
#include "evalGodley.tcd"
#include "eventInterface.tcd"
#include "fontDisplay.tcd"
#include "godleyIcon.tcd"
#include "godleyTable.tcd"
#include "godleyTableWindow.tcd"
#include "grid.tcd"
#include "group.tcd"
#include "handleLockInfo.tcd"
#include "hypercube.tcd"
#include "index.tcd"
#include "intOp.tcd"
#include "item.tcd"
#include "itemT.tcd"
#include "lasso.tcd"
#include "lock.tcd"
#include "noteBase.tcd"
#include "operation.tcd"
#include "operationBase.tcd"
#include "operationType.tcd"
#include "pango.tcd"
#include "pannableTab.tcd"
#include "phillipsDiagram.tcd"
#include "plot.tcd"
#include "plotOptions.tcd"
#include "plotWidget.tcd"
#include "polyRESTProcessBase.tcd"
#include "port.h"
#include "port.tcd"
#include "publication.tcd"
#include "pubTab.tcd"
#include "ravelState.tcd"
#include "renderNativeWindow.tcd"
#include "ravelWrap.tcd"
#include "rungeKutta.tcd"
#include "selection.tcd"
#include "sheet.tcd"
#include "simulation.tcd"
#include "slider.tcd"
#include "SVGItem.tcd"
#include "switchIcon.tcd"
#include "tensorInterface.tcd"
#include "tensorVal.tcd"
#include "units.tcd"
#include "userFunction.h"
#include "userFunction.tcd"
#include "variableInstanceList.h"
#include "variableInstanceList.tcd"
#include "variable.tcd"
#include "variablePane.tcd"
#include "variableType.tcd"
#include "variableValue.tcd"
#include "variableValues.tcd"
#include "wire.tcd"
#include "xvector.tcd"
#include "minsky_epilogue.h"

Go to the source code of this file.

Classes
struct	classdesc_access::access_typescriptAPI< classdesc::Exclude< T > >
struct	classdesc_access::access_typescriptAPI< ecolab::TCLAccessor< T, V, N > >
struct	classdesc_access::access_typescriptAPI< classdesc::PolyPackBase >
struct	classdesc_access::access_typescriptAPI< classdesc::PolyPack< T > >
struct	classdesc_access::access_typescriptAPI< std::vector< civita::any > >
struct	classdesc_access::access_typescriptAPI< minsky::Optional< T > >
struct	classdesc::tn< civita::any >
struct	classdesc::tn< boost::geometry::model::d2::point_xy< T > >
struct	classdesc::tn< RESTProcess_t >
struct	classdesc::tn< std::chrono::time_point< C, D > >
struct	classdesc::tn< std::istream >
struct	classdesc::tn< minsky::PannableTab< minsky::EquationDisplay > >

Namespaces
	classdesc_access
	classdesc
	minsky
	Creation and access to the minskyTCL_obj object, which has code to record whenever Minsky's state changes.

Functions
template<>
string	classdesc::typeName< cairo_t > ()
template<>
string	classdesc::typeName< cairo_surface_t > ()
template<class T , class Base >
enable_if< Not< is_map< Base > >, void >::T	classdesc::typescriptAPI (typescriptAPI_t &t, const string &d)
Minsky &	minsky::minsky ()
	global minsky object More...
void	minsky::doOneEvent (bool idleTasksOnly)
	checks if any GUI events are waiting, and proces an event if so More...
void	exportClass (const std::string &name, const minsky::typescriptAPI_ns::ClassType &klass)
int	main ()

Function Documentation

exportClass()

void exportClass	(	const std::string &	name,
		const minsky::typescriptAPI_ns::ClassType &	klass
	)

Definition at line 186 of file typescriptAPI.cc.

Referenced by main().

{
      cout << "export class "+name+" extends "+(klass.super.empty()? "CppClass": klass.super)+" {\n";

      // properties
      for (auto& prop: klass.properties)
        cout << "  "<<prop.first <<": "<<prop.second.type<<";\n";

      // constructor
      if (!klass.super.empty())
        {
          cout << "  constructor(prefix: string|"<<klass.super<<"){\n";
          cout << "    if (typeof prefix==='string')\n";
          cout << "      super(prefix";
          if (!klass.valueType.empty())
            cout <<","<<klass.valueType;
          cout << ")\n";
          cout << "    else\n";
          cout << "      super(prefix.$prefix()";
          if (!klass.valueType.empty())
            cout <<","<<klass.valueType;
          cout <<")\n";
        }
      else
        {
          cout << "  constructor(prefix: string){\n";
          cout << "    super(prefix);\n";
        }
      for (auto& prop: klass.properties)
        {
          if (!prop.second.construction.empty())
            cout << "    this."<<prop.first<<"="<<prop.second.construction<<"\n";
          else
            cout << "    this."<<prop.first<<"=new "<<prop.second.type<<"(this.$prefix()+'."<<prop.first<<"');\n"; 
        }
      cout << "  }\n";

      // methods
      for (auto& method: klass.methods)
        {
          cout << "  async "<<method.first<<"(";
          for (size_t i=0; i<method.second.args.size(); ++i)
            {
              if (i>0) cout<<",";
              cout<<method.second.args[i].name<<": "<<method.second.args[i].type;
            }
          cout << "): Promise<"<<method.second.returnType<<"> {return this.$callMethod('"<<method.first<<"'";
          for (auto& arg: method.second.args)
            cout<<","<<arg.name;
          cout<<");}\n";
        }
      cout << "}\n\n";
}

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 240 of file typescriptAPI.cc.

References classdesc::typescriptAPI_t::addClass(), classdesc::typescriptAPI_t::addSubclass(), and exportClass().

{
  typescriptAPI_t api;
  api.addClass<Minsky>();

  // supporting types
  api.addClass<Bookmark>();
  api.addClass<Canvas::ZoomCrop>();
  api.addClass<civita::Dimension>();
  api.addClass<civita::Hypercube>();
  api.addClass<civita::Index>();
  api.addClass<civita::ITensor>();
  api.addClass<civita::XVector>();
  api.addClass<DataSpecSchema>();
  api.addClass<ecolab::Plot::LineStyle>();
  api.addClass<EngNotation>();
  api.addClass<EventInterface>();
  api.addClass<GroupItems>();
  api.addClass<HandleLockInfo>();
  api.addClass<Port>();
  api.addClass<PubItem>();
  api.addClass<ravel::HandleState>();
  api.addClass<ravel::RavelState>();
  api.addClass<Units>();
  api.addClass<VariablePaneCell>();
  api.addClass<VariableValue>();
  api.addClass<VariableValues>();
  api["VariableValues"].valueType="VariableValue";
  
  // Item subclasses
  api.addSubclass<DataOp,Item>();
  api.addSubclass<Group,Item>();
  api.addSubclass<GodleyIcon,Item>();
  api.addSubclass<IntOp,Item>();
  api.addSubclass<Lock,Item>();
  api.addSubclass<OperationBase,Item>();
  api.addSubclass<PhillipsFlow,Item>();
  api.addSubclass<PhillipsStock,Item>();
  api.addSubclass<PlotWidget,Item>();
  api.addSubclass<Ravel,Item>();
  api.addSubclass<Sheet,Item>();
  api.addSubclass<SwitchIcon,Item>();
  api.addSubclass<VariableBase,Item>();
  api.addSubclass<UserFunction,Item>();

  // RenderNativeWindow subclasses
  api.addSubclass<RenderNativeWindow, EventInterface>();
  api.addSubclass<Canvas,RenderNativeWindow>();
  api.addSubclass<PannableTab<EquationDisplay>,RenderNativeWindow>();
  api.addSubclass<PhillipsDiagram,RenderNativeWindow>();
  api.addSubclass<PubTab,RenderNativeWindow>();

  
  // to prevent Group recursively calling itself on construction
  api["Group"].properties.erase("parent");
  
  cout << "/*\nThis is a built file, please do not edit.\n";
  cout << "See RESTService/typescriptAPI for more information.\n*/\n\n";
  cout << "import {CppClass, Sequence, Container, Map, Pair} from './backend';\n\n";

  // dummy types
  cout << "class minsky__dummy {}\n";
  cout << "class minsky__EventInterface__KeyPressArgs {}\n";
  cout << "class minsky__GodleyIcon__MoveCellArgs {}\n";
  cout << "class minsky__RenderNativeWindow__RenderFrameArgs {}\n";
  cout << "class minsky__VariableType__TypeT {}\n";
  cout << "class civita__ITensor__Args {}\n";
  cout << "class classdesc__json_pack_t {}\n";
  cout << "class classdesc__pack_t {}\n";
  cout << "class classdesc__RESTProcess_t {}\n";
  cout << "class classdesc__TCL_obj_t {}\n";
  cout << "class ecolab__cairo__Surface {}\n";
  cout<<endl;
  
  // these need to be declared in a specific order
  vector<string> exportFirst{"EventInterface","Item","OperationBase","RenderNativeWindow","VariableBase"};
  for (auto& i: exportFirst) exportClass(i,api[i]);

  cout << "class minsky__Variable<T> extends VariableBase {}\n";

  // then export the rest
  for (auto& i: api)
    if (find(exportFirst.begin(), exportFirst.end(), i.first)==exportFirst.end())
      exportClass(i.first, i.second);

  cout << "export var minsky=new Minsky('minsky');\n";
}

Here is the call graph for this function: