schema3 Namespace Reference

Namespaces
	anonymous_namespace{schema3.cc}

Classes
struct	ExcludedMinsky
	working structure, not serialised More...
struct	Group
struct	IdMap
struct	Item
struct	ItemBase
struct	LockGroup
struct	LockGroupFactory
class	Minsky
struct	MinskyImpl
struct	MinskyItemFactory
struct	Note
struct	PhillipsDiagram
struct	PhillipsFlow
struct	PublicationItem
struct	PublicationTab
struct	Schema1Layout
struct	Slider
struct	Wire

Functions
void	pack (classdesc::pack_t &b, const civita::XVector &a)
void	unpack (classdesc::pack_t &b, civita::XVector &a)
void	pack (classdesc::pack_t &b, const civita::TensorVal &a)
void	unpack (classdesc::pack_t &b, civita::TensorVal &a)
void	populateNote (minsky::NoteBase &x, const Note &y)
void	populateItem (minsky::Item &x, const Item &y)
void	populateWire (minsky::Wire &x, const Wire &y)

Function Documentation

pack() [1/2]

void schema3::pack	(	classdesc::pack_t &	b,
		const civita::XVector &	a
	)

Definition at line 40 of file schema3.cc.

References minsky::str().

Referenced by minsky::DataOp::pack().

  {
    b<<a.name<<a.dimension<<uint64_t(a.size());
    for (const auto& i: a)
      b<<civita::str(i,a.dimension.units);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

pack() [2/2]

void schema3::pack	(	classdesc::pack_t &	b,
		const civita::TensorVal &	a
	)

Definition at line 60 of file schema3.cc.

Referenced by schema3::Item::convertTensorDataFromSchema2(), and schema3::Item::packTensorInit().

  {
    b<<uint64_t(a.size());
    for (auto i: a)
      b<<i;
    b<<uint64_t(a.index().size());
    for (auto i: a.index())
      b<<uint64_t(i);

    b<<uint64_t(a.hypercube().xvectors.size());
    for (const auto& i: a.hypercube().xvectors)
      pack(b, i);
  }

Here is the caller graph for this function:

populateItem()

void schema3::populateItem	(	minsky::Item &	x,
		const Item &	y
	)

Definition at line 475 of file schema3.cc.

References minsky::PlotOptions< Base >::applyPlotOptions(), schema3::Item::arg, schema3::Item::assetClasses, schema3::Item::axis, minsky::NoteBase::bookmark, schema3::ItemBase::bookmark, schema3::Item::bookmarks, schema3::Item::buttonDisplay, schema3::Item::currency, schema3::Item::data, schema3::Item::dataOpData, schema3::Item::dimensions, schema3::Item::editorMode, schema3::Item::expression, minsky::flipped(), schema3::ItemBase::height, minsky::Item::iHeight(), minsky::Item::iWidth(), minsky::Item::m_sf, minsky::Item::m_x, minsky::Item::m_y, schema3::Item::miniPlot, minsky::PlotOptions< Base >::name, schema3::Item::palette, populateNote(), schema3::ItemBase::ports, schema3::Item::ravelState, schema3::ItemBase::rotation, minsky::Item::rotation(), schema3::ItemBase::scaleFactor, schema3::Item::showColSlice, schema3::Item::showSlice, schema3::Item::slider, schema2::RavelState::toRavelRavelState(), schema3::Item::variableDisplay, schema3::ItemBase::width, schema3::ItemBase::x, and schema3::ItemBase::y.

Referenced by schema3::Minsky::populateGroup(), schema3::PhillipsDiagram::populatePhillipsDiagram(), and schema3::Minsky::populatePublicationTabs().

  {
    populateNote(x,y);
    x.m_x=y.x;
    x.m_y=y.y;
    x.m_sf=y.scaleFactor;
    x.rotation(y.rotation);
    x.iWidth(y.width);
    x.iHeight(y.height);
    x.bookmark=y.bookmark;
    if (auto* x1=dynamic_cast<minsky::DataOp*>(&x))
      {
        if (y.name)
          x1->description(*y.name);
        if (y.dataOpData)
          x1->data=*y.dataOpData;
      }
    if (auto* x1=dynamic_cast<minsky::UserFunction*>(&x))
      {
        if (y.name)
          x1->description(*y.name);
        if (y.expression)
          x1->expression=*y.expression;
      }
    
    if (auto* x1=dynamic_cast<minsky::Ravel*>(&x))
      {
        if (y.ravelState)
          {
            x1->applyState(y.ravelState->toRavelRavelState());
            x1->redistributeHandles();
            SchemaHelper::initHandleState(*x1,y.ravelState->toRavelRavelState());
          }
        
        if (y.dimensions)
          x1->axisDimensions=*y.dimensions;
        if (y.editorMode && *y.editorMode!=x1->editorMode())
          x1->toggleEditorMode();
        x1->flipped=minsky::flipped(y.rotation);
      }
    if (auto* x1=dynamic_cast<minsky::Lock*>(&x))
      {
        if (y.ravelState)
          {
            x1->lockedState=y.ravelState->toRavelRavelState();
            x1->tooltip(ravelCAPI::Ravel::description(x1->lockedState));
          }
      }
    if (auto* x1=dynamic_cast<minsky::VariableBase*>(&x))
      {
        if (y.name)
          x1->name(*y.name);
        if (y.slider)
          {
            x1->sliderStepRel(y.slider->stepRel);
            x1->enableSlider(y.slider->visible);
            x1->sliderMin(y.slider->min);
            x1->sliderMax(y.slider->max);
            x1->sliderStep(y.slider->step);
          }
        x1->miniPlotEnabled(y.miniPlot);
        // variableValue attributes populated later once variable is homed in its group
      }
    if (auto* x1=dynamic_cast<minsky::OperationBase*>(&x))
      {
        if (y.axis) x1->axis=*y.axis;
        if (y.arg) x1->arg=*y.arg;
      }
   if (auto* x1=dynamic_cast<minsky::GodleyIcon*>(&x))
      {   
        std::vector<std::vector<std::string>> data;
        std::vector<minsky::GodleyAssetClass::AssetClass> assetClasses;
        if (y.data) data=*y.data;
        if (y.assetClasses) assetClasses=*y.assetClasses;
        SchemaHelper::setPrivates(*x1,data,assetClasses);
        try
          {
            x1->table.orderAssetClasses();
          }
        catch (const std::exception&) {}
        if (y.name) x1->table.title=*y.name;
        if (y.editorMode && *y.editorMode!=x1->editorMode())
          x1->toggleEditorMode();
        if (y.variableDisplay)
          SchemaHelper::setVariableDisplay(*x1, *y.variableDisplay);
        if (y.buttonDisplay && *y.buttonDisplay!=x1->buttonDisplay())
          x1->toggleButtons();
        if (y.currency) x1->currency=*y.currency;
      }
    if (auto* x1=dynamic_cast<minsky::PlotWidget*>(&x))
      {
        x1->bb.update(*x1);        
        if (y.name) x1->title=*y.name;
        y.applyPlotOptions(*x1);
        if (y.palette) x1->palette=*y.palette;
        if (y.ports.size()>x1->nBoundsPorts)
          x1->numLines((y.ports.size()-x1->nBoundsPorts)/4);
      }
    if (auto* x1=dynamic_cast<minsky::Sheet*>(&x))
      {
        if (y.showSlice)
          x1->showRowSlice=*y.showSlice;
        if (y.showColSlice)
          x1->showColSlice=*y.showColSlice;
      }
    if (auto* x1=dynamic_cast<minsky::SwitchIcon*>(&x))
      {
        x1->flipped=minsky::flipped(y.rotation);
        if (y.ports.size()>=2)
          x1->setNumCases(y.ports.size()-2);
      }
    if (auto* x1=dynamic_cast<minsky::Group*>(&x))
      {
        x1->bb.update(*x1);
        if (y.name) x1->title=*y.name;
        if (y.bookmarks)
          {
            x1->bookmarks.clear();
            x1->bookmarks.insert(y.bookmarks->begin(), y.bookmarks->end());
          }
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

populateNote()

void schema3::populateNote	(	minsky::NoteBase &	x,
		const Note &	y
	)

Definition at line 467 of file schema3.cc.

References minsky::NoteBase::detailedText(), schema3::Note::detailedText, minsky::NoteBase::tooltip(), and schema3::Note::tooltip.

Referenced by schema3::Minsky::populateGroup(), populateItem(), and populateWire().

  {
    if (y.detailedText && !y.detailedText->empty())
      x.detailedText(*y.detailedText);
    if (y.tooltip && !y.tooltip->empty())
      x.tooltip(*y.tooltip);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

populateWire()

void schema3::populateWire	(	minsky::Wire &	x,
		const Wire &	y
	)

Definition at line 598 of file schema3.cc.

References minsky::Wire::coords(), schema3::Wire::coords, and populateNote().

Referenced by schema3::Minsky::populateGroup(), and schema3::PhillipsDiagram::populatePhillipsDiagram().

  {
    populateNote(x,y);
    if (y.coords)
      x.coords(*y.coords);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

unpack() [1/2]

void schema3::unpack	(	classdesc::pack_t &	b,
		civita::XVector &	a
	)

Definition at line 47 of file schema3.cc.

  {
    uint64_t size;
    std::string x;
    a.clear();
    b>>a.name>>a.dimension>>size;
    for (size_t i=0; i<size; ++i)
      {
        b>>x;
        a.push_back(x);
      }
  }

unpack() [2/2]

void schema3::unpack	(	classdesc::pack_t &	b,
		civita::TensorVal &	a
	)

Definition at line 75 of file schema3.cc.

Referenced by schema3::Minsky::populateGroup().

  {
    uint64_t sz;
    b>>sz;
    vector<double> data;
    for (size_t i=0; i<sz; ++i)
      {
        data.emplace_back();
        b>>data.back();
      }
    b>>sz;
    set<size_t> index;
    for (size_t i=0; i<sz; ++i)
      {
        uint64_t x;
        b>>x;
        index.insert(x);
      }

    b>>sz;
    civita::Hypercube hc;

    for (size_t i=0; i<sz; ++i)
      {
        civita::XVector xv;
        unpack(b,xv);
        hc.xvectors.push_back(xv);
      }
    assert(std::find_if(index.begin(),index.end(),[&](size_t i){return i>=hc.numElements();})==index.end());
    a.index(std::move(index)); //NOLINT
    a.hypercube(std::move(hc)); //dimension data
    assert(a.size()==data.size());
    memcpy(a.begin(),data.data(),data.size()*sizeof(data[0]));
  }

Here is the caller graph for this function: