minsky::RavelLockGroup Class Reference

#include <ravelWrap.h>

Collaboration diagram for minsky::RavelLockGroup:

Public Member Functions
	RavelLockGroup ()
void	addRavel (const std::weak_ptr< Ravel > &ravel)
const std::vector< std::weak_ptr< Ravel > > &	ravels () const
void	initialBroadcast ()
	broadcast first ravel's state to the remainder More...
void	broadcast (const Ravel &ravel)
	broadcast state from ravel to the lock group More...
unsigned	colour () const
	an identifying tag used to colour locked ravels on canvas More...
void	validateLockHandleInfo ()
	checks handleLockInfo for non repeated handles, etc More...
std::vector< std::string >	allLockHandles () const
	populate handlesToLock by all handles present in the lock group More...
std::vector< std::string >	ravelNames () const
	return tooltips of the ravels in this lockGroup More...
std::vector< std::string >	handleNames (size_t ravel_idx) const
	return the handle descriptions of of ravel ravel_idx in ravels More...
void	setLockHandles (const std::vector< std::string > &handles)
	set handlesToLock to the handles in handles More...
void	addHandleInfo (const std::weak_ptr< Ravel > &ravel)
	add ravel's handles to handleLockInfo, for a ravel stashed in m_ravels More...
void	removeFromGroup (const Ravel &)

Public Attributes
std::vector< HandleLockInfo >	handleLockInfo

Private Attributes
unsigned	m_colour
std::vector< std::weak_ptr< Ravel > >	m_ravels

Static Private Attributes
static unsigned	nextColour =1

Detailed Description

Definition at line 225 of file ravelWrap.h.

Constructor & Destructor Documentation

RavelLockGroup()

minsky::RavelLockGroup::RavelLockGroup ( )

inline

Definition at line 231 of file ravelWrap.h.

{m_colour=nextColour++;}

Member Function Documentation

addHandleInfo()

void minsky::RavelLockGroup::addHandleInfo

(

const std::weak_ptr< Ravel > &

ravel

)

add ravel's handles to handleLockInfo, for a ravel stashed in m_ravels

Definition at line 798 of file ravelWrap.cc.

References handleLockInfo, handleNames(), and m_ravels.

Referenced by addRavel().

  {
    auto ravelIdx=&ravel-m_ravels.data();
    assert(ravelIdx>=0);
    if (ravelIdx<0 || size_t(ravelIdx)>=m_ravels.size()) return;
    if (auto r=ravel.lock())
      {
        auto names=r->handleNames();
        set<string> handleNames(names.begin(), names.end());
        if (names.size()!=handleNames.size())
          r->throw_error("Ambiguous handle names");
        // add corresponding handles to what's already there
        for (auto& hli: handleLockInfo)
          {
            assert(hli.handleNames.size()==m_ravels.size());
            const set<string> lockNames(hli.handleNames.begin(), hli.handleNames.end());
            for (auto& l: lockNames)
              {
                auto hn=handleNames.find(l);
                if (hn!=handleNames.end())
                  {
                    hli.handleNames[ravelIdx]=l;
                    handleNames.erase(hn);
                  }
              }
          }
        // now add in any extras
        for (auto& h: handleNames)
          {
            handleLockInfo.emplace_back();
            handleLockInfo.back().handleNames.resize(m_ravels.size());
            handleLockInfo.back().handleNames[ravelIdx]=h;
          }
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

addRavel()

void minsky::RavelLockGroup::addRavel

(

const std::weak_ptr< Ravel > &

ravel

)

Definition at line 790 of file ravelWrap.cc.

References addHandleInfo(), handleLockInfo, and m_ravels.

  {
    m_ravels.push_back(ravel);
    for (auto& i: handleLockInfo)
      i.handleNames.resize(m_ravels.size());
    addHandleInfo(m_ravels.back());
  }

Here is the call graph for this function:

allLockHandles()

vector< string > minsky::RavelLockGroup::allLockHandles

(

)

const

populate handlesToLock by all handles present in the lock group

Definition at line 737 of file ravelWrap.cc.

References m_ravels.

  {
    set<string> handles;
    for (auto& rr: m_ravels)
      if (auto r=rr.lock())
        {
          auto state=r->getState();
          for (auto& h: state.handleStates)
            handles.insert(h.description);
        }
    return {handles.begin(), handles.end()};
  }

broadcast()

void minsky::RavelLockGroup::broadcast

(

const Ravel &

ravel

)

broadcast state from ravel to the lock group

Definition at line 611 of file ravelWrap.cc.

References minsky::Ravel::getState(), handleLockInfo, and m_ravels.

Referenced by initialBroadcast().

  {
    vector<shared_ptr<Ravel>> lockedRavels;
    size_t ravelIdx=m_ravels.size();
    for (auto& i: m_ravels)
      {
        lockedRavels.push_back(i.lock());
        if (lockedRavels.back().get()==&ravel)
          ravelIdx=lockedRavels.size()-1;
      }
    if (ravelIdx==m_ravels.size()) return; // not in lock group
    
    auto sourceState=ravel.getState();

    if (handleLockInfo.empty()) // default is all handles are locked
      {
        for (auto& i: m_ravels)
          if (auto r=i.lock())
            {
              sourceState.radius=r->radius(); // preserve radius
              r->applyState(sourceState);
            }
        return;
      }

    // reorder source handle states according to handleLockInfo
    vector<const ravel::HandleState*> sourceHandleStates;
    set<string> handlesAdded;
    for (auto& i: handleLockInfo)
      {
        auto hs=find_if(sourceState.handleStates.begin(), sourceState.handleStates.end(),
                        [&](const ravel::HandleState& hs){return hs.description==i.handleNames[ravelIdx];});
        if (hs!=sourceState.handleStates.end())
          {
            sourceHandleStates.emplace_back(&*hs);
            if (!handlesAdded.insert(hs->description).second)
              throw runtime_error("Multiple locks found on handle "+hs->description);
          }
        else
          sourceHandleStates.emplace_back(nullptr);
      }

    assert(sourceHandleStates.size()==handleLockInfo.size());
    
    for (size_t ri=0; ri<m_ravels.size(); ++ri)
      if (auto r=m_ravels[ri].lock())
        {
          if (r.get()==&ravel) continue;
          auto state=r->getState();
          set<string> outputHandles(state.outputHandles.begin(), state.outputHandles.end());
          for (size_t i=0; i<handleLockInfo.size(); ++i)
            {
              if (!sourceHandleStates[i]) continue;
              auto& sourceHandleState=*sourceHandleStates[i];
              
              auto& hlInfo=handleLockInfo[i];
              auto handleState=find_if(state.handleStates.begin(), state.handleStates.end(),
                                            [&](ravel::HandleState& s){return s.description==hlInfo.handleNames[ri];});
              if (handleState!=state.handleStates.end())
                {
                  if (hlInfo.slicer)
                    {
                      handleState->sliceLabel=sourceHandleState.sliceLabel;
                      if (find(sourceState.outputHandles.begin(), sourceState.outputHandles.end(), sourceHandleState.description)!=sourceState.outputHandles.end())
                        // is an output handle
                        outputHandles.insert(handleState->description);
                      else
                        outputHandles.erase(handleState->description);
                    }
                  if (hlInfo.orientation)
                    {
                      handleState->x=sourceHandleState.x;
                      handleState->y=sourceHandleState.y;
                      handleState->collapsed=sourceHandleState.collapsed;
                      handleState->reductionOp=sourceHandleState.reductionOp;
                    }
                  if (hlInfo.calipers)
                    {
                      handleState->displayFilterCaliper=sourceHandleState.displayFilterCaliper;
                      handleState->minLabel=sourceHandleState.minLabel;
                      handleState->maxLabel=sourceHandleState.maxLabel;
                    }
                  if (hlInfo.order)
                    {
                      handleState->order=sourceHandleState.order;
                      handleState->customOrder=sourceHandleState.customOrder;
                    }
                }
            }
          // reorder output handle list according to the source ravel output order.
          state.outputHandles.clear();
          for (auto& i: sourceState.outputHandles)
            {
              auto o=outputHandles.find(i);
              if (o!=outputHandles.end())
                {
                  state.outputHandles.push_back(i);
                  outputHandles.erase(o);
                }
            }
          // add remaining handles in order.
          state.outputHandles.insert(state.outputHandles.end(), outputHandles.begin(), outputHandles.end());
          r->applyState(state);
        }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

colour()

unsigned minsky::RavelLockGroup::colour ( ) const

inline

an identifying tag used to colour locked ravels on canvas

Definition at line 239 of file ravelWrap.h.

{return m_colour;}

handleNames()

std::vector< std::string > minsky::RavelLockGroup::handleNames

(

size_t

ravel_idx

)

const

return the handle descriptions of of ravel ravel_idx in ravels

Definition at line 762 of file ravelWrap.cc.

References m_ravels.

Referenced by addHandleInfo(), and setLockHandles().

  {
    if (auto rr=m_ravels[ravel_idx].lock())
      return rr->handleNames();
    return {};
  }

Here is the caller graph for this function:

initialBroadcast()

void minsky::RavelLockGroup::initialBroadcast

(

)

broadcast first ravel's state to the remainder

Definition at line 604 of file ravelWrap.cc.

References broadcast(), and m_ravels.

  {
    if (!m_ravels.empty())
      if (auto r=m_ravels.front().lock())
        broadcast(*r);
  }

Here is the call graph for this function:

ravelNames()

std::vector< std::string > minsky::RavelLockGroup::ravelNames

(

)

const

return tooltips of the ravels in this lockGroup

Definition at line 750 of file ravelWrap.cc.

References m_ravels, and minsky::to_string().

  {
    std::vector<std::string> r;
    int cnt=0;
    for (auto& i: m_ravels)
      if (auto rr=i.lock())
        r.emplace_back(rr->tooltip().empty()? to_string(cnt++): rr->tooltip());
      else
        r.emplace_back("<invalid>");
    return r;
  }

Here is the call graph for this function:

ravels()

const std::vector<std::weak_ptr<Ravel> >& minsky::RavelLockGroup::ravels ( ) const

inline

Definition at line 233 of file ravelWrap.h.

{return m_ravels;}

removeFromGroup()

void minsky::RavelLockGroup::removeFromGroup

(

const Ravel &

ravel

)

Definition at line 834 of file ravelWrap.cc.

References handleLockInfo, and m_ravels.

  {
    auto found=find_if(m_ravels.begin(), m_ravels.end(),
                    [&](const weak_ptr<Ravel>& i){
                      if (auto r=i.lock())
                        return r.get()==&ravel;
                      return false;
                    });
    if (found==m_ravels.end()) return;
    for (auto& i: handleLockInfo)
      i.handleNames.erase(i.handleNames.begin()+(found-m_ravels.begin()));
    m_ravels.erase(found);
    if (m_ravels.size()==1)
      if (auto r=m_ravels[0].lock())
        r->lockGroup.reset(); // this may delete this, so should be last
  }

setLockHandles()

void minsky::RavelLockGroup::setLockHandles

(

const std::vector< std::string > &

handles

)

set handlesToLock to the handles in handles

Definition at line 769 of file ravelWrap.cc.

References handleLockInfo, handleNames(), and m_ravels.

  {
    handleLockInfo.clear();
    std::vector<std::set<std::string>> handleNames;
    for (auto& rp: m_ravels)
      if (auto r=rp.lock())
        {
          auto names=r->handleNames();
          handleNames.emplace_back(names.begin(), names.end());
        }
      else
        handleNames.emplace_back();
    
    for (auto& h: handles)
      {
        handleLockInfo.emplace_back();
        for (size_t i=0; i<m_ravels.size(); ++i)
          handleLockInfo.back().handleNames.push_back(handleNames[i].contains(h)? h: "");
      }
  }

Here is the call graph for this function:

validateLockHandleInfo()

void minsky::RavelLockGroup::validateLockHandleInfo

(

)

checks handleLockInfo for non repeated handles, etc

Exceptions

if

error

Definition at line 717 of file ravelWrap.cc.

References handleLockInfo, and m_ravels.

  {
    vector<set<string>> checkHandleNames(m_ravels.size());
    for (auto& hl: handleLockInfo)
      {
        if (hl.handleNames.size()!=m_ravels.size())
          throw runtime_error("Insufficient data on line");
        for (size_t i=0; i<hl.handleNames.size(); ++i)
          {
            auto& nm=hl.handleNames[i];
            // non-breaking space 0xa0 not treated as space by isspace
            if (find_if(nm.begin(), nm.end(), [](unsigned char i){return !isspace(i)&&i!=0xa0;})==nm.end())
              continue; // disregard wholly white space strings
            if (!checkHandleNames[i].insert(nm).second) // check for duplicated handle names in a column
              throw runtime_error("duplicate handle name "+nm);
          }
      }
  }

Member Data Documentation

handleLockInfo

std::vector<HandleLockInfo> minsky::RavelLockGroup::handleLockInfo

Definition at line 240 of file ravelWrap.h.

Referenced by addHandleInfo(), addRavel(), broadcast(), removeFromGroup(), setLockHandles(), and validateLockHandleInfo().

m_colour

unsigned minsky::RavelLockGroup::m_colour

private

Definition at line 228 of file ravelWrap.h.

m_ravels

std::vector<std::weak_ptr<Ravel> > minsky::RavelLockGroup::m_ravels

private

Definition at line 229 of file ravelWrap.h.

Referenced by addHandleInfo(), addRavel(), allLockHandles(), broadcast(), handleNames(), initialBroadcast(), ravelNames(), removeFromGroup(), setLockHandles(), and validateLockHandleInfo().

nextColour

unsigned minsky::RavelLockGroup::nextColour =1

staticprivate

Definition at line 227 of file ravelWrap.h.

---

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

• model/ravelWrap.h
• model/ravelWrap.cc