//: Call void call(PARAM1 param1) { Signal_v1_Generic *data = impl; data->in_call = true; std::list<SlotIterator> remove_slots; try { data->in_call_remove_slots = &remove_slots; // call slots connected to signal: for (SlotIterator slot_it = data->slots.begin(); slot_it != data->slots.end(); slot_it++) { Slot slot = *slot_it; // skip slot if it has no more references left in application. // (make it pending for removal) if (slot->get_slot_ref() == 0 && slot->is_persistent() == false) { if (std::find(remove_slots.begin(), remove_slots.end(), slot_it)==remove_slots.end()) remove_slots.push_back(slot_it); } slot->call(param1); if (data->deleted) break; } } catch (...) { catch_final(data, remove_slots); throw; } catch_final(data, remove_slots); }
/** * Build a vector of Slot from the global_slots map with the * offset applied. * * The clears the global_slots map. * @returns true if the offset was applied correctly, false otherwise. */ bool ApplyOffset(uint16_t offset, SlotList *all_slots) { bool ok = true; all_slots->reserve(global_slots.size()); SlotActionMap::const_iterator iter = global_slots.begin(); for (; iter != global_slots.end(); ++iter) { Slot *slots = iter->second; if (slots->SlotOffset() + offset >= ola::DMX_UNIVERSE_SIZE) { OLA_FATAL << "Slot " << slots->SlotOffset() << " + offset " << offset << " is greater than " << ola::DMX_UNIVERSE_SIZE - 1; ok = false; break; } slots->SetSlotOffset(slots->SlotOffset() + offset); all_slots->push_back(slots); } if (!ok) { all_slots->clear(); for (iter = global_slots.begin(); iter != global_slots.end(); ++iter) delete iter->second; } global_slots.clear(); return ok; }
void Pass::runGraphite(Machine & m, FiniteStateMachine & fsm) const { Slot *s = m.slotMap().segment.first(); if (!s || !testPassConstraint(m)) return; Slot *currHigh = s->next(); #if !defined GRAPHITE2_NTRACING if (fsm.dbgout) *fsm.dbgout << "rules" << json::array; json::closer rules_array_closer(fsm.dbgout); #endif m.slotMap().highwater(currHigh); int lc = m_iMaxLoop; do { findNDoRule(s, m, fsm); if (s && (m.slotMap().highpassed() || s == m.slotMap().highwater() || --lc == 0)) { if (!lc) { // if (dbgout) *dbgout << json::item << json::flat << rule_event(-1, s, 1); s = m.slotMap().highwater(); } lc = m_iMaxLoop; if (s) m.slotMap().highwater(s->next()); } } while (s); }
void JSONSerializer::Traverse(const shared_ptr<Node>& root) { mNodes[root] = ++mNodeCount; /// Traverse slots for (auto slotPair : root->GetSerializableSlots()) { Slot* slot = slotPair.second; if (slot->mIsMultiSlot) { for (auto& node : slot->GetDirectMultiNodes()) { auto it = mNodes.find(node); if (it == mNodes.end()) { Traverse(node); } } } else { shared_ptr<Node> node = slot->GetDirectNode(); if (node == nullptr || slot->IsDefaulted()) continue; auto it = mNodes.find(node); if (it == mNodes.end()) { Traverse(node); } } } mNodesList.push_back(root); }
void Pass::dumpRuleEventOutput(const FiniteStateMachine & fsm, const Rule & r, Slot * const last_slot) const { *fsm.dbgout << json::item << json::flat << json::object << "id" << &r - m_rules << "failed" << false << "input" << json::flat << json::object << "start" << objectid(dslot(&fsm.slots.segment, input_slot(fsm.slots, 0))) << "length" << r.sort - r.preContext << json::close // close "input" << json::close // close Rule object << json::close // close considered array << "output" << json::object << "range" << json::flat << json::object << "start" << objectid(dslot(&fsm.slots.segment, input_slot(fsm.slots, 0))) << "end" << objectid(dslot(&fsm.slots.segment, last_slot)) << json::close // close "input" << "slots" << json::array; const Position rsb_prepos = last_slot ? last_slot->origin() : fsm.slots.segment.advance(); fsm.slots.segment.positionSlots(0); for(Slot * slot = output_slot(fsm.slots, 0); slot != last_slot; slot = slot->next()) *fsm.dbgout << dslot(&fsm.slots.segment, slot); *fsm.dbgout << json::close // close "slots" << "postshift" << (last_slot ? last_slot->origin() : fsm.slots.segment.advance()) - rsb_prepos << json::close; // close "output" object }
void Segment::linkClusters(Slot *s, Slot * end) { end = end->next(); for (; s != end && !s->isBase(); s = s->next()); Slot * ls = s; if (m_dir & 1) { for (; s != end; s = s->next()) { if (!s->isBase()) continue; s->sibling(ls); ls = s; } } else { for (; s != end; s = s->next()) { if (!s->isBase()) continue; ls->sibling(s); ls = s; } } }
// ------------------------------------------------------------------------------------------------ void Signal::DisconnectFunc(Function & func) { // Don't attempt to search anything if there's no head if (m_Head == nullptr) { return; } const SQHash hash = Slot{NullObject(), func}.mFuncHash; // Walk down the chain and remove the matching nodes for (Slot * node = m_Head, * next = nullptr; node != nullptr; node = next) { // Grab the next node upfront next = node->mNext; // Is this our node? if (node->mFuncHash == hash) { // Is this the head? if (node == m_Head) { m_Head = next; // Move the head to the next one } // Detach it from the chain node->Detach(); // Delete the node instance delete node; } } }
coherence( Target& obj, MPI_Comm comm ) : myself_( -1 ), comm_( comm ), rslot_(), wslot_(), eslot_(), req_( NULL ) { MPI_Comm_rank( comm_, &myself_ ); obj.coherence_setup( *this ); if ( 0 < rslot_.size() ) req_ = new MPI_Request[ rslot_.size() ]; }
Slot::~Slot() { // remove connections with other slots Slot * s; while( connections_.get(&s)) { s->remove_connection(this); connections_.pop(); } }
~Signal_v1_Generic() { for (SlotIterator slot_it = slots.begin(); slot_it != slots.end(); slot_it++) { Slot slot = *slot_it; slot->release_signal_ref(owner); } }
Signal_v1(const Signal_v1 ©) : Signal(copy), impl(new Signal_v1_Generic(this)) { impl->slots = copy.impl->slots; for (SlotIterator slot_it = impl->slots.begin(); slot_it != impl->slots.end(); slot_it++) { Slot slot = *slot_it; slot->add_signal_ref(this); } }
void DropItemBehavior::OnDragLeave(BaseComponent* sender, const DragEventArgs& e) { ContentControl* control = (ContentControl*)sender; Slot* slot = (Slot*)control->GetContent(); slot->SetIsDragOver(false); e.handled = true; }
Slot* Slot::create(Ball* ball, Vec2 pos){ Slot* slot = new (std::nothrow) Slot(); if (slot && slot->init(ball,pos)){ slot->autorelease(); return slot; } CC_SAFE_DELETE(slot); return nullptr; }
Slot::Slot(const Slot &cpy) { const int *st = cpy.GetStrTime(); const int *et = cpy.GetEndTime(); for (register int i = 0; i < 6; i++) { str_time[i] = st[i]; end_time[i] = et[i]; } movieID = cpy.GetMovieID(); cost = cpy.GetCost(); }
void BaseSkeleton::setAttachment (const string &slotName, const string &attachmentName) { for (int i = 0, n = slots.size(); i < n; i++) { Slot *slot = slots[i]; if (slot->data->name == slotName) { slot->setAttachment(getAttachment(i, attachmentName)); return; } } throw invalid_argument("Slot not found: " + slotName); }
void Segment::doMirror(uint16 aMirror) { Slot * s; for (s = m_first; s; s = s->next()) { unsigned short g = glyphAttr(s->gid(), aMirror); if (g && (!(dir() & 4) || !glyphAttr(s->gid(), aMirror + 1))) s->setGlyph(this, g); } }
static void ConnectAction( const std::string & valuestr, const SignalMap & signalmap, Slot & slot) { typename SignalMap::const_iterator it = signalmap.find(valuestr); if (it != signalmap.end()) slot.connect(*it->second); else slot.call(valuestr); }
// ------------------------------------------------------------------------------------------------ void Signal::Tail(Object & env, Function & func) { // Don't attempt to search anything if there's no head if (m_Head == nullptr) { m_Head = new Slot(env, func, nullptr); // We're done here return; } const Slot slot{env, func}; // Don't attempt to search anything if there's only one element if (m_Head->mNext == nullptr) { // Is it already inserted? if (*m_Head != slot) { m_Head->mNext = new Slot(env, func, nullptr); // Link with the head m_Head->mNext->mPrev = m_Head; } // We're done here return; } // Grab the head node Slot * node = m_Head, * prev = nullptr; // Walk down the chain and find a matching node for (; node != nullptr; prev = node, node = node->mNext) { if (*node == slot) { break; // Found it } } // Have we found anything? if (node == nullptr) { // Create the slot now node = new Slot(env, func, nullptr); } else { // Walk down the chain until the end while (prev->mNext != nullptr) { prev = prev->mNext; } // Finally, detach the node from it's current position node->Detach(); } // Knowing 'prev' points to last element node->AttachPrev(prev); }
void SSpineWidget::UpdateMesh(int32 LayerId, FSlateWindowElementList& OutDrawElements, const FGeometry& AllottedGeometry, Skeleton* Skeleton) { TArray<FVector> vertices; TArray<int32> indices; TArray<FVector2D> uvs; TArray<FColor> colors; TArray<FVector> darkColors; int idx = 0; int meshSection = 0; UMaterialInstanceDynamic* lastMaterial = nullptr; SkeletonClipping &clipper = widget->clipper; Vector<float> &worldVertices = widget->worldVertices; float depthOffset = 0; unsigned short quadIndices[] = { 0, 1, 2, 0, 2, 3 }; for (int i = 0; i < (int)Skeleton->getSlots().size(); ++i) { Vector<float> &attachmentVertices = worldVertices; unsigned short* attachmentIndices = nullptr; int numVertices; int numIndices; AtlasRegion* attachmentAtlasRegion = nullptr; Color attachmentColor; attachmentColor.set(1, 1, 1, 1); float* attachmentUvs = nullptr; Slot* slot = Skeleton->getDrawOrder()[i]; Attachment* attachment = slot->getAttachment(); if (!attachment) continue; if (!attachment->getRTTI().isExactly(RegionAttachment::rtti) && !attachment->getRTTI().isExactly(MeshAttachment::rtti) && !attachment->getRTTI().isExactly(ClippingAttachment::rtti)) continue; if (attachment->getRTTI().isExactly(RegionAttachment::rtti)) { RegionAttachment* regionAttachment = (RegionAttachment*)attachment; attachmentColor.set(regionAttachment->getColor()); attachmentAtlasRegion = (AtlasRegion*)regionAttachment->getRendererObject(); regionAttachment->computeWorldVertices(slot->getBone(), attachmentVertices, 0, 2); attachmentIndices = quadIndices; attachmentUvs = regionAttachment->getUVs().buffer(); numVertices = 4; numIndices = 6; } else if (attachment->getRTTI().isExactly(MeshAttachment::rtti)) { MeshAttachment* mesh = (MeshAttachment*)attachment; attachmentColor.set(mesh->getColor()); attachmentAtlasRegion = (AtlasRegion*)mesh->getRendererObject(); mesh->computeWorldVertices(*slot, 0, mesh->getWorldVerticesLength(), attachmentVertices, 0, 2); attachmentIndices = mesh->getTriangles().buffer(); attachmentUvs = mesh->getUVs().buffer(); numVertices = mesh->getWorldVerticesLength() >> 1; numIndices = mesh->getTriangles().size(); } else /* clipping */ {
bool Segment::initCollisions() { m_collisions = grzeroalloc<SlotCollision>(slotCount()); if (!m_collisions) return false; for (Slot *p = m_first; p; p = p->next()) if (p->index() < slotCount()) ::new (collisionInfo(p)) SlotCollision(this, p); else return false; return true; }
void Parser::makeConnection(Graph *_g,std::string _input, std::string _output) { Slot *in = Utilities::findSlot(_g, _input); Slot *out = Utilities::findSlot(_g, _output); if(in->getName() != "empty" && out->getName() != "empty") { in->linkToSlot(out); return; } std::cout<<"something went wrong\n"; }
static void dispatch_event(struct epoll_event *event) { Slot *slot = (Slot*) event->data.ptr; if (!slot->handler(slot->fd, event->events, slot->data)) { /* We are assuming here that the set of events returned by epoll doesn't * contain this file descriptor more than once. epoll(7) says that events * will be combined, so we should be safe. * * Note that closing the file descriptor automatically removes it from the * epoll set. */ close(slot->fd); free(slot); } }
//Create and return slot object Slot* Slot::create(cocos2d::Vec2 position) { Slot* pSprite = new Slot(); if (pSprite) { pSprite->autorelease(); pSprite->init(position); return pSprite; } CC_SAFE_DELETE(pSprite); return NULL; }
Signal_v1 &operator =(const Signal_v1 ©) { if (impl->in_call) impl->deleted = true; else delete impl; impl = new Signal_v1_Generic(this); impl->slots = copy.impl->slots; for (SlotIterator slot_it = impl->slots.begin(); slot_it != impl->slots.end(); slot_it++) { Slot slot = *slot_it; slot->add_signal_ref(this); } return *this; }
void catch_final(Signal_v1_Generic *data, std::list<SlotIterator> &remove_slots) { data->in_call_remove_slots = 0; // remove all slots no longer connected to any Slot. typename std::list<SlotIterator>::iterator remove_it; for (remove_it = remove_slots.begin(); remove_it != remove_slots.end(); remove_it++) { Slot slot = **remove_it; slot->release_signal_ref(this); data->slots.erase(*remove_it); } data->in_call = false; if (data->deleted) delete data; }
bool Face::runGraphite(Segment *seg, const Silf *aSilf) const { #if !defined GRAPHITE2_NTRACING json * dbgout = logger(); if (dbgout) { *dbgout << json::object << "id" << objectid(seg) << "passes" << json::array; } #endif // if ((seg->dir() & 1) != aSilf->dir()) // seg->reverseSlots(); if ((seg->dir() & 3) == 3 && aSilf->bidiPass() == 0xFF) seg->doMirror(aSilf->aMirror()); bool res = aSilf->runGraphite(seg, 0, aSilf->positionPass(), true); if (res) { seg->associateChars(0, seg->charInfoCount()); if (aSilf->flags() & 0x20) res &= seg->initCollisions(); res &= aSilf->runGraphite(seg, aSilf->positionPass(), aSilf->numPasses(), false); } #if !defined GRAPHITE2_NTRACING if (dbgout) { seg->positionSlots(0, 0, 0, aSilf->dir()); *dbgout << json::item << json::close // Close up the passes array << "output" << json::array; for(Slot * s = seg->first(); s; s = s->next()) *dbgout << dslot(seg, s); seg->finalise(0); // Call this here to fix up charinfo back indexes. *dbgout << json::close << "advance" << seg->advance() << "chars" << json::array; for(size_t i = 0, n = seg->charInfoCount(); i != n; ++i) *dbgout << json::flat << *seg->charinfo(i); *dbgout << json::close // Close up the chars array << json::close; // Close up the segment object } #endif return res; }
// ------------------------------------------------------------------------------------------------ void Signal::Head(Object & env, Function & func) { // Don't attempt to search anything if there's no head if (m_Head == nullptr) { m_Head = new Slot(env, func, nullptr); // We're done here return; } const Slot slot{env, func}; // Don't attempt to search anything if there's only one element if (m_Head->mNext == nullptr) { // Is it already inserted? if (*m_Head != slot) { m_Head = new Slot(env, func, m_Head); } // We're done here return; } // Grab the head node Slot * node = m_Head; // Walk down the chain and find a matching node for (; node != nullptr; node = node->mNext) { if (*node == slot) { break; // Found it } } // Have we found anything? if (node == nullptr) { m_Head = new Slot(env, func, m_Head); // Lead everyone } // Is it the head already? else if (m_Head != node) { node->AttachNext(m_Head); // We're the head now m_Head = node; } }
void SceneSaveLoad::saveSlot(int position) { // First save at that position if(slots.size() < position){ Slot slot; slot.setPlayer(*game_obj->player); slots.push_back(slot); } // Update save else{ Slot slot = slots[position-1]; slot.setPlayer(*game_obj->player); slots[position-1] = slot; } game_obj->file_loader->saveSlots(&slots); }
void operator()( void *base ) { if ( comm_ == NULL ) return; for ( unsigned int i = 0; i < rslot_.size(); ++i ) { coherent_type& slot( rslot_[ i ] ); MPI_Irecv( base, 1, slot.type, slot.pair, myself_, comm_, &req_[ i ] ); } for ( unsigned int i = 0; i < wslot_.size(); ++i ) { coherent_type& slot( wslot_[ i ] ); MPI_Send( base, 1, slot.type, slot.pair, slot.pair, comm_ ); } if ( 0 < rslot_.size() ) MPI_Waitall( rslot_.size(), req_, MPI_STATUSES_IGNORE ); }
bool Slot::connect(Slot& target) { if (!&target) { raise("Slot::connect(): invalid target slot given (null)"); } bool ret = true; ret &= _addTarget(&target); ret &= target._addTarget(this); return ret; }