minsky::GroupItems Class Reference

#include <group.h>

Inheritance diagram for minsky::GroupItems:

Collaboration diagram for minsky::GroupItems:

Public Member Functions
	GroupItems ()
virtual	~GroupItems ()
	GroupItems (const GroupItems &x)
GroupItems &	operator= (const GroupItems &)
void	clear ()
bool	empty () const
virtual bool	nocycles () const =0
	tests that groups are arranged heirarchically without any recurrence More...
template<class M , class C >
const M::value_type	findAny (M GroupItems::*map, C c) const
	search for the first item in the heirarchy of map for which c is true. M::value_type must evaluate in a boolean environment to false if not valid C is of signature bool(M::value_type) More...
template<class R , class M , class C , class X >
std::vector< R >	findAll (C c, M(GroupItems::*m), X xfm) const
	finds all items/wires matching criterion c. Found items are transformed by xfm More...
WirePtr	removeWire (const Wire &)
GroupPtr	removeGroup (const Group &)
ItemPtr	findItem (const Item &it) const
	finds item within this group or subgroups. Returns null if not found More...
GroupPtr	findGroup (const Group &it) const
	finds group within this group or subgroups. Returns null if not found More...
WirePtr	findWire (const Wire &it) const
	finds wire within this group or subgroups. Returns null if not found More...
template<class C >
std::vector< ItemPtr >	findItems (C c) const
	returns list of items matching criterion c More...
template<class C >
std::vector< WirePtr >	findWires (C c) const
	returns list of wires matching criterion c More...
template<class C >
std::vector< GroupPtr >	findGroups (C c) const
	returns list of groups matching criterion c More...
ItemPtr	addItem (Item *it, bool inSchema=false)
	add item, ownership is passed More...
virtual ItemPtr	addItem (const std::shared_ptr< Item > &, bool inSchema=false)
ItemPtr	removeItem (const Item &)
GroupPtr	addGroup (const std::shared_ptr< Group > &)
GroupPtr	addGroup (Group *g)
WirePtr	addWire (const Item &from, const Item &to, unsigned toPortIdx)
	add a wire from item from, to item to, connecting to the toIdx port of to More...
WirePtr	addWire (const std::shared_ptr< Wire > &)
WirePtr	addWire (Wire *w)
WirePtr	addWire (const std::weak_ptr< Port > &from, const std::weak_ptr< Port > &to)
std::size_t	numItems () const
	total number of items in this and child groups More...
std::size_t	numWires () const
	total number of wires in this and child groups More...
std::size_t	numGroups () const
	total number of groups in this and child groups More...
void	removeDisplayPlot ()
	remove the display plot More...
template<class M , class O >
bool	recursiveDo (M GroupItems::*map, O op) const
	Perform action heirarchically on elements of map map. If op returns true, the operation terminates. returns true if operation terminates early, false if every element processed. O has signature bool(M, M::const_iterator) More...
template<class M , class O >
bool	recursiveDo (M GroupItems::*map, O op)
	O has signature bool(M&, M::iterator) More...

Static Public Member Functions
static void	adjustWiresGroup (Wire &w)
	adjust wire's group to be the least common ancestor of its ports More...

Public Attributes
Items	items
Groups	groups
Wires	wires
std::set< Bookmark >	bookmarks
std::vector< VariablePtr >	inVariables
std::vector< VariablePtr >	outVariables
std::vector< VariablePtr >	createdIOvariables
classdesc::Exclude< std::weak_ptr< Group > >	self
	weak ref to this More...
classdesc::Exclude< std::shared_ptr< PlotWidget > >	displayPlot
	plot widget used for group icon More...

Protected Member Functions
WirePtr	addWire (const Item &from, const Item &to, unsigned toPortIdx, const std::vector< float > &coords)
	add a wire from item from, to item to, connecting to the toIdx port of to, with coordinates More...
WirePtr	addWire (const std::weak_ptr< Port > &from, const std::weak_ptr< Port > &to, const std::vector< float > &coords)
void	renameVar (const GroupPtr &origGroup, VariableBase &v)
	rename variable so that it maintains most general scope possible More...
	CLASSDESC_ACCESS (GroupItems)

Private Attributes
bool	inDestructor =false

Friends
class	Canvas

Detailed Description

Definition at line 57 of file group.h.

Constructor & Destructor Documentation

GroupItems() [1/2]

minsky::GroupItems::GroupItems ( )

inline

Definition at line 84 of file group.h.

{}

~GroupItems()

virtual minsky::GroupItems::~GroupItems ( )

inlinevirtual

Definition at line 85 of file group.h.

References clear(), and inDestructor.

{inDestructor=true; clear();}

Here is the call graph for this function:

GroupItems() [2/2]

minsky::GroupItems::GroupItems ( const GroupItems &  x )

inline

Definition at line 87 of file group.h.

{};

Member Function Documentation

addGroup() [1/2]

GroupPtr minsky::GroupItems::addGroup

(

const std::shared_ptr< Group > &

g

)

Definition at line 659 of file group.cc.

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

  {
    assert(g);
    auto origGroup=g->group.lock();
    if (origGroup.get()==this) return g; // nothing to do
    if (origGroup)
      origGroup->removeGroup(*g);
    groups.push_back(g);
    g->group=self;
    g->self=groups.back();
    assert(nocycles());
    return groups.back();
  }

Here is the caller graph for this function:

addGroup() [2/2]

GroupPtr minsky::GroupItems::addGroup ( Group *  g )

inline

Definition at line 173 of file group.h.

References addGroup().

Referenced by addGroup().

{return addGroup(std::shared_ptr<Group>(g));}

Here is the call graph for this function:

Here is the caller graph for this function:

addItem() [1/2]

ItemPtr minsky::GroupItems::addItem ( Item *  it, bool  inSchema = false  )

inline

add item, ownership is passed

Definition at line 165 of file group.h.

References addItem().

Referenced by addItem(), and minsky::Group::addItem().

{return addItem(std::shared_ptr<Item>(it),inSchema);}

Here is the call graph for this function:

Here is the caller graph for this function:

addItem() [2/2]

ItemPtr minsky::GroupItems::addItem ( const std::shared_ptr< Item > &  it, bool  inSchema = false  )

virtual

add item.

Parameters

inSchema

- if building a group from schema processing, rather than generally. Does not adjust item position within group if true.

Reimplemented in minsky::Group.

Definition at line 331 of file group.cc.

References minsky::Minsky::bookmarkRefresh(), TCLcmd::trap::init, and pyminsky::minsky.

  {
    if (!it) return it;
    minsky().bookmarkRefresh();
    if (auto x=dynamic_pointer_cast<Group>(it))
      return addGroup(x);
   
    // stash position
    const float x=it->x(), y=it->y();
    auto origGroup=it->group.lock();

    if (origGroup.get()==this) return it; // nothing to do.
    if (origGroup)
      origGroup->removeItem(*it);

    // stash init value to initialise new variableValue
    string init;
    string units;
    if (auto v=it->variableCast())
      {
        init=v->init();
        units=v->unitsStr();
      }
    
    it->group=self;
    if (!inSchema) it->moveTo(x,y);

    // take into account new scope
    if (auto v=it->variableCast())
      {
        if (!inSchema && origGroup)
          renameVar(origGroup, *v);
        v->init(init); //NB calls ensureValueExists()
        // if value didn't exist before, units will be empty. Do not overwrite any previous units set. For #1461.
        if (units.length()) v->setUnits(units);
      }
     
    // move wire to highest common group
    for (size_t i=0; i<it->portsSize(); ++i)
      {
        auto p=it->ports(i).lock();
        assert(p);
        for (auto& w: p->wires())
          {
            assert(w);
            adjustWiresGroup(*w);
          }
      }

    // need to deal with integrals especially because of the attached variable
    if (auto intOp=dynamic_cast<IntOp*>(it.get()))
      if (intOp->intVar)
        {
          if (!inSchema && origGroup)
            renameVar(origGroup, *intOp->intVar);
          if (auto oldG=intOp->intVar->group.lock())
           {
                 
             if (oldG.get()!=this)
               addItem(oldG->removeItem(*intOp->intVar),inSchema);
           }
          else
            addItem(intOp->intVar,inSchema);
          if (intOp->coupled())
            intOp->intVar->controller=it;
          else
            intOp->intVar->controller.reset();
        }
         
    items.push_back(it);
    return items.back();
  }

Here is the call graph for this function:

addWire() [1/6]

WirePtr minsky::GroupItems::addWire ( const Item &  from, const Item &  to, unsigned  toPortIdx, const std::vector< float > &  coords  )

inlineprotected

add a wire from item from, to item to, connecting to the toIdx port of to, with coordinates

Definition at line 63 of file group.h.

References minsky::Item::ports(), and minsky::Item::portsSize().

Referenced by addWire(), minsky::Wire::moveIntoGroup(), and schema3::Minsky::populateGroup().

    {
      if (toPortIdx>=to.portsSize()) return WirePtr();
      return addWire(from.ports(0), to.ports(toPortIdx), coords);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

addWire() [2/6]

WirePtr minsky::GroupItems::addWire ( const std::weak_ptr< Port > &  from, const std::weak_ptr< Port > &  to, const std::vector< float > &  coords  )

protected

Definition at line 680 of file group.cc.

References minsky::cminsky(), and minsky::Minsky::inputWired().

  {
    auto fromP=fromPw.lock(), toP=toPw.lock();
    // disallow self-wiring
    if (!fromP || !toP || &fromP->item()==&toP->item()) 
      return WirePtr();

    // wire must go from an output port to an input port
    if (fromP->input() || !toP->input())
      return WirePtr();

    // check that multiple input wires are only to binary ops.
    if (!toP->wires().empty() && !toP->multiWireAllowed())
      return WirePtr();

    // check that a wire doesn't already exist connecting these two ports
    for (auto& w: toP->wires())
      if (w->from()==fromP)
        return WirePtr();

    // disallow wiring the input of an already defined variable
    if (auto v=toP->item().variableCast())
      if (cminsky().inputWired(v->valueId()))
        return {};
    
    auto w=addWire(new Wire(fromP, toP, coords));
    adjustWiresGroup(*w);

    return w;
  }

Here is the call graph for this function:

addWire() [3/6]

WirePtr minsky::GroupItems::addWire ( const Item &  from, const Item &  to, unsigned  toPortIdx  )

inline

add a wire from item from, to item to, connecting to the toIdx port of to

Definition at line 177 of file group.h.

References addWire().

    {return addWire(from, to, toPortIdx, {});}

Here is the call graph for this function:

addWire() [4/6]

WirePtr minsky::GroupItems::addWire

(

const std::shared_ptr< Wire > &

w

)

Definition at line 673 of file group.cc.

  {
    assert(w->from() && w->to());
    wires.push_back(w);
    return wires.back();
  }

addWire() [5/6]

WirePtr minsky::GroupItems::addWire ( Wire *  w )

inline

Definition at line 180 of file group.h.

References addWire().

Referenced by addWire().

{return addWire(std::shared_ptr<Wire>(w));}

Here is the call graph for this function:

Here is the caller graph for this function:

addWire() [6/6]

WirePtr minsky::GroupItems::addWire ( const std::weak_ptr< Port > &  from, const std::weak_ptr< Port > &  to  )

inline

Definition at line 181 of file group.h.

References addWire().

    {return addWire(from,to,{});}

Here is the call graph for this function:

adjustWiresGroup()

void minsky::GroupItems::adjustWiresGroup ( Wire &  w )

static

adjust wire's group to be the least common ancestor of its ports

Definition at line 404 of file group.cc.

  {
    // Find common ancestor group, and move wire to it
    assert(w.from() && w.to());
    shared_ptr<Group> p1=w.from()->item().group.lock(), p2=w.to()->item().group.lock();
    assert(p1 && p2);
    unsigned l1=p1->level(), l2=p2->level();
    for (; p1 && l1>l2; l1--) p1=p1->group.lock();
    for (; p2 && l2>l1; l2--) p2=p2->group.lock();
    
    while (p1 && p2 && p1!=p2) 
      {
        assert(p1 && p2);
        p1=p1->group.lock();
        p2=p2->group.lock();
      }
    if (!p1 || !p2) return;
    w.moveIntoGroup(*p1);
  }

CLASSDESC_ACCESS()

minsky::GroupItems::CLASSDESC_ACCESS ( GroupItems  )

protected

clear()

void minsky::GroupItems::clear ( )

inline

Definition at line 91 of file group.h.

References bookmarks, groups, inVariables, items, outVariables, and wires.

Referenced by minsky::Group::moveContents(), and ~GroupItems().

                 {
      // controlled items need to be removed from a copy
      auto itemsCopy=items;
      for (auto& i: itemsCopy) i->removeControlledItems(*this);
      items.clear();
      groups.clear();
      wires.clear();
      inVariables.clear();
      outVariables.clear();
      bookmarks.clear();
    }

Here is the caller graph for this function:

empty()

bool minsky::GroupItems::empty ( ) const

inline

Definition at line 102 of file group.h.

References groups, items, and wires.

{return items.empty() && groups.empty() && wires.empty();}

findAll()

template<class R , class M , class C , class X >

std::vector< R > minsky::GroupItems::findAll	(	C	c,
		M GroupItems::*	m,
		X	xfm
	)		const

finds all items/wires matching criterion c. Found items are transformed by xfm

Definition at line 454 of file group.h.

References groups, and items.

                                                                     {
    std::vector<R> r;
    for (auto& i: this->*m)
      {
        assert(i);
        if (c(i)) r.push_back(xfm(i));
      }
    
    for (auto& i: groups)
      {
        assert(i);
        auto items=i->findAll<R>(c,m,xfm);
        r.insert(r.end(), items.begin(), items.end());
      }
    return r;
  }

findAny()

template<class M , class C >

const M::value_type minsky::GroupItems::findAny	(	M GroupItems::*	map,
		C	c
	)		const

search for the first item in the heirarchy of map for which c is true. M::value_type must evaluate in a boolean environment to false if not valid C is of signature bool(M::value_type)

Definition at line 442 of file group.h.

References groups.

Referenced by findGroup(), and findWire().

  {
    for (auto& i: this->*map)
      if (c(i))
        return i;
    for (auto& g: groups)
      if (auto& r=g->findAny(map, c))
        return r;
    return typename M::value_type();
  }

Here is the caller graph for this function:

findGroup()

GroupPtr minsky::GroupItems::findGroup ( const Group &  it ) const

inline

finds group within this group or subgroups. Returns null if not found

Definition at line 139 of file group.h.

References findAny(), and groups.

    {return findAny(&GroupItems::groups, [&](const GroupPtr& x){return &*x==⁢});}

Here is the call graph for this function:

findGroups()

template<class C >

std::vector<GroupPtr> minsky::GroupItems::findGroups ( C  c ) const

inline

returns list of groups matching criterion c

Definition at line 160 of file group.h.

References groups.

                                              {
      return findAll<GroupPtr>(c,&GroupItems::groups,[](GroupPtr x){return x;});
    }

findItem()

ItemPtr minsky::GroupItems::findItem

(

const Item &

it

)

const

finds item within this group or subgroups. Returns null if not found

Definition at line 291 of file group.cc.

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

  {
    // start by looking in the group it thnks it belongs to
    if (auto g=it.group.lock())
      if (g.get()!=this) 
        {
          auto i=g->findItem(it);
          if (i) return i;
        }
    return findAny(&Group::items, [&](const ItemPtr& x){return x.get()==⁢});
  }

Here is the caller graph for this function:

findItems()

template<class C >

std::vector<ItemPtr> minsky::GroupItems::findItems ( C  c ) const

inline

returns list of items matching criterion c

Definition at line 148 of file group.h.

References items.

                                            {
      return findAll<ItemPtr>(c,&GroupItems::items,[](ItemPtr x){return x;});
    }

findWire()

WirePtr minsky::GroupItems::findWire ( const Wire &  it ) const

inline

finds wire within this group or subgroups. Returns null if not found

Definition at line 143 of file group.h.

References findAny(), and wires.

    {return findAny(&GroupItems::wires, [&](const WirePtr& x){return x.get()==⁢});}

Here is the call graph for this function:

findWires()

template<class C >

std::vector<WirePtr> minsky::GroupItems::findWires ( C  c ) const

inline

returns list of wires matching criterion c

Definition at line 154 of file group.h.

References wires.

                                            {
      return findAll<WirePtr>(c,&GroupItems::wires,[](WirePtr x){return x;});
    }

nocycles()

virtual bool minsky::GroupItems::nocycles ( ) const

pure virtual

tests that groups are arranged heirarchically without any recurrence

Implemented in minsky::Group.

numGroups()

size_t minsky::GroupItems::numGroups

(

)

const

total number of groups in this and child groups

Definition at line 491 of file group.cc.

  {
    size_t count=groups.size();
    for (auto& i: groups) count+=i->numGroups();
    return count;
  }

numItems()

size_t minsky::GroupItems::numItems

(

)

const

total number of items in this and child groups

Definition at line 477 of file group.cc.

  {
    size_t count=items.size();
    for (auto& i: groups) count+=i->numItems();
    return count;
  }

numWires()

size_t minsky::GroupItems::numWires

(

)

const

total number of wires in this and child groups

Definition at line 484 of file group.cc.

  {
    size_t count=wires.size();
    for (auto& i: groups) count+=i->numWires();
    return count;
  }

operator=()

GroupItems& minsky::GroupItems::operator= ( const GroupItems &  )

inline

Definition at line 88 of file group.h.

{return *this;}

recursiveDo() [1/2]

template<class M , class O >

bool minsky::GroupItems::recursiveDo ( M GroupItems::*  map, O  op  ) const

inline

Perform action heirarchically on elements of map map. If op returns true, the operation terminates. returns true if operation terminates early, false if every element processed. O has signature bool(M, M::const_iterator)

Definition at line 111 of file group.h.

References minsky::GroupRecursiveDo(), and minsky::op.

Referenced by schema3::Minsky::Minsky(), minsky::Wire::moveIntoGroup(), and minsky::VariableInstanceList::VariableInstanceList().

    {return GroupRecursiveDo(*this,map,op);}

Here is the call graph for this function:

Here is the caller graph for this function:

recursiveDo() [2/2]

template<class M , class O >

bool minsky::GroupItems::recursiveDo ( M GroupItems::*  map, O  op  )

inline

O has signature bool(M&, M::iterator)

Definition at line 115 of file group.h.

References minsky::GroupRecursiveDo(), and minsky::op.

    {return GroupRecursiveDo(*this,map,op);}

Here is the call graph for this function:

removeDisplayPlot()

void minsky::GroupItems::removeDisplayPlot ( )

inline

remove the display plot

Definition at line 196 of file group.h.

References displayPlot.

                             {
      displayPlot.reset();
    }

removeGroup()

GroupPtr minsky::GroupItems::removeGroup

(

const Group &

group

)

Definition at line 275 of file group.cc.

References minsky::group.

  {
    for (auto i=groups.begin(); i!=groups.end(); ++i)
      if (i->get()==&group)
        {
          GroupPtr r=*i;
          groups.erase(i);
          return r;
        }

    for (auto& g: groups)
      if (GroupPtr r=g->removeGroup(group))
        return r;
    return GroupPtr();
  }

removeItem()

ItemPtr minsky::GroupItems::removeItem

(

const Item &

it

)

Definition at line 212 of file group.cc.

References minsky::Item::bookmarkId(), and minsky::VariableBase::controller.

Referenced by schema3::Minsky::populateGroup(), minsky::IntOp::removeControlledItems(), and minsky::GodleyIcon::removeControlledItems().

  {
    if (it.plotWidgetCast()==displayPlot.get()) removeDisplayPlot();
    if (!inDestructor) bookmarks.erase(it.bookmarkId());
    for (auto i=items.begin(); i!=items.end(); ++i)
      if (i->get()==&it)
        {
          ItemPtr r=*i;
          items.erase(i);
          if (auto v=r->variableCast())
              if (v->ioVar())
                {
                 remove(inVariables, r);
                 remove(outVariables, r);
                 remove(createdIOvariables, r);
                 v->controller.reset();
                }
          return r;
        }

    for (auto i=groups.begin(); i!=groups.end(); ++i)
      if (i->get()==&it)
        {
          ItemPtr r=*i;
          groups.erase(i);
          return r;
        }
    
    
    for (auto& g: groups)
      if (ItemPtr r=g->removeItem(it))
        return r;
    return ItemPtr();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

removeWire()

WirePtr minsky::GroupItems::removeWire

(

const Wire &

w

)

Definition at line 259 of file group.cc.

  {
    for (auto i=wires.begin(); i!=wires.end(); ++i)
      if (i->get()==&w)
        {
          WirePtr r=*i;
          wires.erase(i);
          return r;
        }

    for (auto& g: groups)
      if (WirePtr r=g->removeWire(w))
        return r;
    return WirePtr();
  }

renameVar()

void minsky::GroupItems::renameVar ( const GroupPtr &  origGroup, VariableBase &  v  )

protected

rename variable so that it maintains most general scope possible

Definition at line 303 of file group.cc.

References minsky::VariableBase::name(), minsky::VariableBase::rawName(), and minsky::valueId().

  {
    if (auto thisGroup=self.lock())
      {
        if (origGroup->higher(*thisGroup))
          {
            // moving local var into an inner group, make global
            if (v.rawName()[0]!=':')
              v.name(':'+v.rawName());
          }
        else if (thisGroup->higher(*origGroup))
          {
            // moving global var into an outer group, link up with variable of same name (if existing)
            if (v.name()[0]==':')
              for (auto& i: items)
                if (auto vv=i->variableCast())
                  if (vv->name()==v.name().substr(1))
                    v.name(v.name().substr(1));
          }
        else
          // moving between unrelated groups
          if (v.name()[0]==':' && valueId(thisGroup,v.name()) != valueId(origGroup,v.name()))
            // maintain linkage if possible, otherwise make local
            v.name(v.name().substr(1));
      }
  }

Here is the call graph for this function:

Friends And Related Function Documentation

Canvas

friend class Canvas

friend

Definition at line 76 of file group.h.

Member Data Documentation

bookmarks

std::set<Bookmark> minsky::GroupItems::bookmarks

Definition at line 81 of file group.h.

Referenced by minsky::Group::addBookmarkXY(), minsky::Group::bookmarkList(), clear(), minsky::Group::deleteBookmark(), and minsky::Group::gotoBookmark().

createdIOvariables

std::vector<VariablePtr> minsky::GroupItems::createdIOvariables

Definition at line 83 of file group.h.

displayPlot

classdesc::Exclude<std::shared_ptr<PlotWidget> > minsky::GroupItems::displayPlot

plot widget used for group icon

Definition at line 194 of file group.h.

Referenced by removeDisplayPlot().

groups

Groups minsky::GroupItems::groups

Definition at line 79 of file group.h.

Referenced by clear(), empty(), findAll(), findAny(), findGroup(), findGroups(), minsky::Selection::insertGroup(), minsky::layoutGroup(), schema3::Minsky::Minsky(), minsky::Group::moveContents(), minsky::randomizeLayout(), MathDAG::SystemOfEquations::SystemOfEquations(), and minsky::anonymous_namespace{autoLayout.cc}::totalArea().

inDestructor

bool minsky::GroupItems::inDestructor =false

private

Definition at line 59 of file group.h.

Referenced by ~GroupItems().

inVariables

std::vector<VariablePtr> minsky::GroupItems::inVariables

Definition at line 82 of file group.h.

Referenced by minsky::Group::addInputVar(), clear(), minsky::Group::deleteAttachedWires(), schema3::Minsky::Minsky(), and schema3::Minsky::populateGroup().

items

Items minsky::GroupItems::items

Definition at line 78 of file group.h.

Referenced by clear(), empty(), findAll(), findItems(), minsky::MinskyTCL::findObject(), minsky::MinskyTCL::findVariable(), minsky::PhillipsDiagram::init(), minsky::Ravel::joinLockGroup(), minsky::layoutGroup(), minsky::Ravel::lockGroupColours(), schema3::Minsky::Minsky(), minsky::Group::moveContents(), minsky::GodleyTable::nameUnique(), minsky::randomizeLayout(), minsky::Ravel::Ravel(), MathDAG::SystemOfEquations::SystemOfEquations(), minsky::anonymous_namespace{autoLayout.cc}::totalArea(), minsky::VariableBase::units(), MathDAG::SystemOfEquations::updatePortVariableValue(), and minsky::VariableInstanceList::VariableInstanceList().

outVariables

std::vector<VariablePtr> minsky::GroupItems::outVariables

Definition at line 82 of file group.h.

Referenced by minsky::Group::addOutputVar(), clear(), minsky::Group::deleteAttachedWires(), schema3::Minsky::Minsky(), and schema3::Minsky::populateGroup().

self

classdesc::Exclude<std::weak_ptr<Group> > minsky::GroupItems::self

weak ref to this

Definition at line 89 of file group.h.

wires

Wires minsky::GroupItems::wires

Definition at line 80 of file group.h.

Referenced by clear(), empty(), findWire(), findWires(), minsky::layoutGroup(), schema3::Minsky::Minsky(), and minsky::Wire::moveIntoGroup().

---

The documentation for this class was generated from the following files:

• model/group.h
• model/group.cc