T* add(T* component) { if (componentOperationHandler != nullptr && componentOperationHandler->isActive()) componentOperationHandler->add(this, component); else addInternal(component); return component; }
void FieldInfos::read(IndexInputPtr input, const String& fileName) { int32_t firstInt = input->readVInt(); format = firstInt < 0 ? firstInt : FORMAT_PRE; // This is a real format? if (format != FORMAT_PRE && format != FORMAT_START) boost::throw_exception(CorruptIndexException(L"unrecognized format " + StringUtils::toString(format) + L" in file \"" + fileName + L"\"")); int32_t size = format == FORMAT_PRE ? firstInt : input->readVInt(); // read in the size if required for (int32_t i = 0; i < size; ++i) { String name(input->readString()); uint8_t bits = input->readByte(); addInternal(name, (bits & IS_INDEXED) != 0, (bits & STORE_TERMVECTOR) != 0, (bits & STORE_POSITIONS_WITH_TERMVECTOR) != 0, (bits & STORE_OFFSET_WITH_TERMVECTOR) != 0, (bits & OMIT_NORMS) != 0, (bits & STORE_PAYLOADS) != 0, (bits & OMIT_TERM_FREQ_AND_POSITIONS) != 0); } if (input->getFilePointer() != input->length()) { boost::throw_exception(CorruptIndexException(L"did not read all bytes from file \"" + fileName + L"\": read " + StringUtils::toString(input->getFilePointer()) + L" vs size " + StringUtils::toString(input->length()))); } }
void KdTree::addInternal(KdNode* node,int cd,VecItem* item){ if( item->getPosition()[cd] < node->item->getPosition()[cd] ){ if( node->left == 0){ node->left = new KdNode(item,node->left); m_size++; }else{ addInternal(node->left,(cd+1)%m_k,item); } }else{ if( node->right == 0){ node->right = new KdNode(item,node->right); m_size++; }else{ addInternal(node->right,(cd+1)%m_k,item); } } }
void KdTree::addItem(VecItem* item){ if( m_root == 0){ m_root = new KdNode(item,m_root); m_size++; }else{ addInternal(m_root,0,item); } }
FieldInfoPtr FieldInfos::add(const String& name, bool isIndexed, bool storeTermVector, bool storePositionWithTermVector, bool storeOffsetWithTermVector, bool omitNorms, bool storePayloads, bool omitTermFreqAndPositions) { SyncLock syncLock(this); FieldInfoPtr fi(fieldInfo(name)); if (!fi) return addInternal(name, isIndexed, storeTermVector, storePositionWithTermVector, storeOffsetWithTermVector, omitNorms, storePayloads, omitTermFreqAndPositions); else fi->update(isIndexed, storeTermVector, storePositionWithTermVector, storeOffsetWithTermVector, omitNorms, storePayloads, omitTermFreqAndPositions); return fi; }
bool DOMSettableTokenList::toggle(const AtomicString& token, ExceptionCode& ec) { if (!validateToken(token, ec)) return false; if (m_tokens.contains(token)) { removeInternal(token); return false; } addInternal(token); return true; }
bool DOMTokenList::toggle(const AtomicString& token, ExceptionState& exceptionState) { if (!validateToken(token, exceptionState)) return false; if (containsInternal(token)) { removeInternal(token); return false; } addInternal(token); return true; }
bool DOMTokenList::toggle(const AtomicString& token, bool force, ExceptionState& exceptionState) { if (!validateToken(token, exceptionState)) return false; if (force) addInternal(token); else removeInternal(token); return force; }
/** * <p>Adds a component via a unqiue ptr to an existing component via moving.</p> * * <p>In short, if you create a component stored in a std::unique_ptr, you want to call: <br> * <tt>entity->add(std::move(component));</tt><br> * and remember not to use the component after moving it; use getComponent. * </p> * @param component the component to add. * @return this {@link Entity} for chaining. */ template<typename C> Entity &add(std::unique_ptr<C> &&component) { internal::verify_component_type<C>(); auto typeIndex = std::type_index(typeid(C)); if (operationHandler != nullptr) { operationHandler->add(this, std::move(component), typeIndex); } else { addInternal(std::move(component), typeIndex); } return *this; }
void Operation::add() { backup(); runInternal(); if ( addInternal() ) { list.push(this); createParamUi(); button=new RadioButton(names[type],tips[type],historyCbk,this); button->setGroup(0); history->addWidget(button); button->select(); currentOp=this; } else delete this; }
/** * <p>Constructs a new object of type C (subclassing ashley::Component) using <em>args...</em> for construction.</p> * * <p>If a {@link Component} of the same type already exists, it'll be replaced and destroyed without being retrievable * from this class again.</p> * @return This {@link Entity} for easy chaining */ template<typename C, typename ...Args> Entity &add(Args&&... args) { internal::verify_component_type<C>(); const auto typeIndex = std::type_index(typeid(C)); auto component = std::unique_ptr<Component>(new C(args...)); if (operationHandler != nullptr) { operationHandler->add(this, std::move(component), typeIndex); } else { addInternal(std::move(component), typeIndex); } return *this; // return add<C>(std::unique_ptr<C>(new C(args...))); }
/** * * @brief creates transitions for 'dup' mirroring 'orig' outgoing transitions * * @param - orig: the state that is being duplicated * @param - dup: the state that is duplicating 'orig' * */ void TransitionStorage::dupTransOutgoing( State orig, State dup ) { // Duplicate outgoing internal transitions. const Info::Internals & from = T_info.fromTrans(orig); for( Info::InternalIterator it = from.begin(); it != from.end(); it++ ) { Internal iTrans(dup,getInternalSym(*it),getTarget(*it)); addInternal(iTrans); } // Duplicate call site call transitions. const Info::Calls & call = T_info.callTrans(orig); for( Info::CallIterator it = call.begin(); it != call.end(); it++ ) { Call cTrans(dup,getCallSym(*it),getEntry(*it)); addCall(cTrans); } // Duplicate exit point return transitions. const Info::Returns & exit = T_info.exitTrans(orig); for( Info::ReturnIterator it = exit.begin(); it != exit.end(); it++ ) { Return rTrans(dup,getCallSite(*it),getReturnSym(*it),getReturnSite(*it)); addReturn(rTrans); } // Q: Do we want to do these? Seems inconsistent. -Evan // A: Aditya says 'yes', and thinks we need it. So we definitely don't // want to change it without looking at uses and compensating. // Duplicate call predecessor return transitions. const Info::Returns & pred = T_info.predTrans(orig); for( Info::ReturnIterator it = pred.begin(); it != pred.end(); it++ ) { Return rTrans(getExit(*it),dup,getReturnSym(*it),getReturnSite(*it)); addReturn(rTrans); } }
/** * * @brief add all transitions in the given collection of transitions to this * collection of transitions * * @param - addTransitionStorage: the collection of transitions to add to this * collection of transitions * */ void TransitionStorage::addAllTrans( TransitionStorage addTransSet ) { //Add call transitions. for(CallIterator it = addTransSet.beginCall(); it != addTransSet.endCall(); it ++ ) { addCall(*it); } //Add internal transitions. for(InternalIterator it = addTransSet.beginInternal(); it != addTransSet.endInternal(); it ++ ) { addInternal(*it); } //Add return transitions. for(ReturnIterator it = addTransSet.beginReturn(); it != addTransSet.endReturn(); it ++ ) { addReturn(*it); } }
void EntityEngine::processPendingComponentOperations() { for (auto componentOperation : componentOperations) { auto entity = componentOperation->entity; auto component = componentOperation->component; auto componentId = componentOperation->componentId; switch (componentOperation->type) { case ComponentOperation::ADD: entity->addInternal(component, componentId); break; case ComponentOperation::REMOVE: entity->removeInternal(componentId); break; } updateFamilyMembership(entity); } componentOperations.clear(); }
/** * * @brief add an internal transition to the NWA * * @param - from: the state the edge departs from * @param - sym: the symbol labeling the edge * @param - to: the state the edge arrives to * @return false if the internal transition already exists in the NWA * */ bool TransitionStorage::addInternal( State from, Symbol sym, State to ) { Internal it(from,sym,to); return addInternal(it); }
/** * * @brief creates transitions for 'dup' mirroring 'orig' transitions * * @param - orig: the state that is being duplicated * @param - dup: the state that is duplicating 'orig' * */ void TransitionStorage::dupTrans( State orig, State dup ) { //Duplicate outgoing internal transitions. const Info::Internals & from = T_info.fromTrans(orig); for( Info::InternalIterator it = from.begin(); it != from.end(); it++ ) { Internal iTrans(dup,getInternalSym(*it),getTarget(*it)); addInternal(iTrans); // Q: This is also inconsistent with dupTransOutgoing, which didn't do // anything special with self loops. -Evan // A: Aditya says yes, but this is again what McVeto(?) needs. // dupTrans is used in 'duplicateState', but dupTransOutgoing is // different. if( orig == getTarget(*it) ) //Handle self-loops. { Internal loop(dup,getInternalSym(*it),dup); addInternal(loop); } } //Duplicate incoming internal transitions. const Info::Internals & to = T_info.toTrans(orig); for( Info::InternalIterator it = to.begin(); it != to.end(); it++ ) { Internal iTrans(getSource(*it),getInternalSym(*it),dup); addInternal(iTrans); } //Duplicate call site call transitions. const Info::Calls & call = T_info.callTrans(orig); for( Info::CallIterator it = call.begin(); it != call.end(); it++ ) { Call cTrans(dup,getCallSym(*it),getEntry(*it)); addCall(cTrans); if( orig == getEntry(*it) ) //Handle self-loops. { Call loop(dup,getCallSym(*it),dup); addCall(loop); } } //Duplicate entry point call transitions. const Info::Calls & entry = T_info.entryTrans(orig); for( Info::CallIterator it = entry.begin(); it != entry.end(); it++ ) { Call cTrans(getCallSite(*it),getCallSym(*it),dup); addCall(cTrans); } //Duplicate exit point return transitions. const Info::Returns & exit = T_info.exitTrans(orig); for( Info::ReturnIterator it = exit.begin(); it != exit.end(); it++ ) { Return rTrans(dup,getCallSite(*it),getReturnSym(*it),getReturnSite(*it)); addReturn(rTrans); if( orig == getCallSite(*it) ) //Handle self-loops. { Return loop(dup,dup,getReturnSym(*it),getReturnSite(*it)); addReturn(loop); } if( orig == getReturnSite(*it) ) //Handle self-loops. { Return loop(dup,getCallSite(*it),getReturnSym(*it),dup); addReturn(loop); } if( orig == getCallSite(*it) && orig == getReturnSite(*it) ) //Handle self-loops. { Return loop(dup,dup,getReturnSym(*it),dup); addReturn(loop); } } //Duplicate call predecessor return transitions. const Info::Returns & pred = T_info.predTrans(orig); for( Info::ReturnIterator it = pred.begin(); it != pred.end(); it++ ) { Return rTrans(getExit(*it),dup,getReturnSym(*it),getReturnSite(*it)); addReturn(rTrans); if( orig == getReturnSite(*it) ) //Handle self-loops. { Return loop(getExit(*it),dup,getReturnSym(*it),dup); addReturn(loop); } } //Duplicate return site return transitions. const Info::Returns & ret = T_info.retTrans(orig); for( Info::ReturnIterator it = ret.begin(); it != ret.end(); it++ ) { Return rTrans(getExit(*it),getCallSite(*it),getReturnSym(*it),dup); addReturn(rTrans); } }
void DOMTokenList::add(const Vector<String>& tokens, ExceptionCode& ec) { addInternal(tokens.data(), tokens.size(), ec); }
void DOMTokenList::add(const WTF::AtomicString& token, ExceptionCode& ec) { addInternal(&token.string(), 1, ec); }
void DOMSettableTokenList::add(const AtomicString& token, ExceptionCode& ec) { if (!validateToken(token, ec) || m_tokens.contains(token)) return; addInternal(token); }