void AnimationChannel::removeDuplicates() { LOG(3, " Removing duplicates for channel with target attribute: %u.\n", _targetAttrib); int startCount = _keytimes.size(); size_t propSize = Transform::getPropertySize(_targetAttrib); if (propSize > 1 && !_interpolations.empty() && _interpolations[0] == LINEAR) { size_t prevIndex = 0; std::vector<float>::iterator prevStart = _keyValues.begin(); std::vector<float>::iterator prevEnd = prevStart + propSize - 1; size_t i = 1; for (i = 1; i < _keytimes.size(); ++i) { std::vector<float>::iterator start = _keyValues.begin() + i * propSize; std::vector<float>::iterator end = start + propSize - 1; if (!equal(prevStart, prevEnd, start) || i == _keytimes.size() - 1) { if (i - prevIndex > 2) { deleteRange(prevIndex+1, i, propSize); i = prevIndex; prevStart = _keyValues.begin() + i * propSize; prevEnd = prevStart + propSize - 1; } else { prevStart = start; prevEnd = end; prevIndex = i; } } } if (i - 1 - prevIndex >= 2) { deleteRange(prevIndex+1, i, propSize); } } LOG(3, " Removed %d duplicate keyframes from channel.\n", startCount- _keytimes.size()); }
void EditableTextComponent::keyTyped(const KeyEventUnrecPtr e) { if(getEnabled() && getEditable() && !(e->getModifiers() &( KeyEvent::KEY_MODIFIER_ALT | KeyEvent::KEY_MODIFIER_CONTROL | KeyEvent::KEY_MODIFIER_META ))) { if(e->getKeyChar()>31 && e->getKeyChar() < 127) { if(hasSelection()) { deleteSelectedText(); setCaretPosition(_TextSelectionStart); } insert(std::string( 1,e->getKeyChar() ), _TextSelectionStart); _TextSelectionStart = getCaretPosition(); _TextSelectionEnd = _TextSelectionStart; } if(e->getKey()== e->KEY_BACK_SPACE) { if(hasSelection()) { deleteSelectedText(); } else { //erase at the current caret position Int32 DeleteIndex(getCaretPosition()); if(DeleteIndex != 0) { moveCaret(-1); deleteRange(DeleteIndex-1, DeleteIndex); } } } if(e->getKey()== e->KEY_DELETE) { if(hasSelection()) { deleteSelectedText(); } else if(getText().size()>0) { //erase at the current caret position deleteRange(getCaretPosition(), getCaretPosition()+1); _TextSelectionStart = getCaretPosition(); _TextSelectionEnd = _TextSelectionStart; } } } switch(e->getKey()) { case KeyEvent::KEY_RIGHT: case KeyEvent::KEY_KEYPAD_RIGHT: moveCaret(1); break; case KeyEvent::KEY_LEFT: case KeyEvent::KEY_KEYPAD_LEFT: moveCaret(-1); break; case KeyEvent::KEY_V: if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND) { paste(); } break; case KeyEvent::KEY_C: if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND) { copy(); } break; case KeyEvent::KEY_X: if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND) { cut(); } break; case KeyEvent::KEY_A: if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND) { selectAll(); } break; } Inherited::keyTyped(e); }
bool RangeDeleter::deleteNow(OperationContext* txn, const RangeDeleterOptions& options, string* errMsg) { if (stopRequested()) { *errMsg = "deleter is already stopped."; return false; } string dummy; if (errMsg == NULL) errMsg = &dummy; const string& ns(options.range.ns); const BSONObj& min(options.range.minKey); const BSONObj& max(options.range.maxKey); NSMinMax deleteRange(ns, min, max); { boost::lock_guard<boost::mutex> sl(_queueMutex); if (!canEnqueue_inlock(ns, min, max, errMsg)) { return false; } _deleteSet.insert(&deleteRange); // Note: count for pending deletes is an integral part of the shutdown story. // Therefore, to simplify things, there is no "pending" state for deletes in // deleteNow, the state transition is simply inProgress -> done. _deletesInProgress++; } set<CursorId> cursorsToWait; if (options.waitForOpenCursors) { _env->getCursorIds(txn, ns, &cursorsToWait); } long long checkIntervalMillis = 5; RangeDeleteEntry taskDetails(options); taskDetails.stats.queueStartTS = jsTime(); for (; !cursorsToWait.empty(); sleepmillis(checkIntervalMillis)) { logCursorsWaiting(&taskDetails); set<CursorId> cursorsNow; _env->getCursorIds(txn, ns, &cursorsNow); set<CursorId> cursorsLeft; std::set_intersection(cursorsToWait.begin(), cursorsToWait.end(), cursorsNow.begin(), cursorsNow.end(), std::inserter(cursorsLeft, cursorsLeft.end())); cursorsToWait.swap(cursorsLeft); if (stopRequested()) { *errMsg = "deleter was stopped."; boost::lock_guard<boost::mutex> sl(_queueMutex); _deleteSet.erase(&deleteRange); _deletesInProgress--; if (_deletesInProgress == 0) { _nothingInProgressCV.notify_one(); } return false; } if (checkIntervalMillis < kMaxCursorCheckIntervalMillis) { checkIntervalMillis *= 2; } } taskDetails.stats.queueEndTS = jsTime(); taskDetails.stats.deleteStartTS = jsTime(); bool result = _env->deleteRange(txn, taskDetails, &taskDetails.stats.deletedDocCount, errMsg); taskDetails.stats.deleteEndTS = jsTime(); if (result) { taskDetails.stats.waitForReplStartTS = jsTime(); result = _waitForMajority(txn, errMsg); taskDetails.stats.waitForReplEndTS = jsTime(); } { boost::lock_guard<boost::mutex> sl(_queueMutex); _deleteSet.erase(&deleteRange); _deletesInProgress--; if (_deletesInProgress == 0) { _nothingInProgressCV.notify_one(); } } recordDelStats(new DeleteJobStats(taskDetails.stats)); return result; }
bool RangeDeleter::deleteNow(const std::string& ns, const BSONObj& min, const BSONObj& max, const BSONObj& shardKeyPattern, bool secondaryThrottle, string* errMsg) { if (stopRequested()) { *errMsg = "deleter is already stopped."; return false; } string dummy; if (errMsg == NULL) errMsg = &dummy; NSMinMax deleteRange(ns, min, max); { scoped_lock sl(_queueMutex); if (!canEnqueue_inlock(ns, min, max, errMsg)) { return false; } _deleteSet.insert(&deleteRange); _stats->incTotalDeletes_inlock(); // Note: count for pending deletes is an integral part of the shutdown story. // Therefore, to simplify things, there is no "pending" state for deletes in // deleteNow, the state transition is simply inProgress -> done. _stats->incInProgressDeletes_inlock(); } set<CursorId> cursorsToWait; _env->getCursorIds(ns, &cursorsToWait); long long checkIntervalMillis = 5; if (!cursorsToWait.empty()) { log() << "rangeDeleter waiting for " << cursorsToWait.size() << " cursors in " << ns << " to finish" << endl; } while (!cursorsToWait.empty()) { set<CursorId> cursorsNow; _env->getCursorIds(ns, &cursorsNow); set<CursorId> cursorsLeft; std::set_intersection(cursorsToWait.begin(), cursorsToWait.end(), cursorsNow.begin(), cursorsNow.end(), std::inserter(cursorsLeft, cursorsLeft.end())); cursorsToWait.swap(cursorsLeft); if (stopRequested()) { *errMsg = "deleter was stopped."; scoped_lock sl(_queueMutex); _deleteSet.erase(&deleteRange); _stats->decInProgressDeletes_inlock(); _stats->decTotalDeletes_inlock(); if (!_stats->hasInProgress_inlock()) { _nothingInProgressCV.notify_one(); } return false; } if (checkIntervalMillis < MaxCurorCheckIntervalMillis) { checkIntervalMillis *= 2; } sleepmillis(checkIntervalMillis); } bool result = _env->deleteRange(ns, min, max, shardKeyPattern, secondaryThrottle, errMsg); { scoped_lock sl(_queueMutex); _deleteSet.erase(&deleteRange); _stats->decInProgressDeletes_inlock(); _stats->decTotalDeletes_inlock(); if (!_stats->hasInProgress_inlock()) { _nothingInProgressCV.notify_one(); } } return result; }
void TEditor::handleEvent( TEvent& event ) { TView::handleEvent( event ); convertEvent( event ); Boolean centerCursor = Boolean(!cursorVisible()); uchar selectMode = 0; if( selecting == True || (getShiftState() & 0x03) != 0 ) selectMode = smExtend; switch( event.what ) { case evMouseDown: if( event.mouse.doubleClick == True ) selectMode |= smDouble; do { lock(); if( event.what == evMouseAuto ) { TPoint mouse = makeLocal( event.mouse.where ); TPoint d = delta; if( mouse.x < 0 ) d.x--; if( mouse.x >= size.x ) d.x++; if( mouse.y < 0 ) d.y--; if( mouse.y >= size.y ) d.y++; scrollTo(d.x, d.y); } setCurPtr(getMousePtr(event.mouse.where), selectMode); selectMode |= smExtend; unlock(); } while( mouseEvent(event, evMouseMove + evMouseAuto) ); break; case evKeyDown: if( event.keyDown.charScan.charCode == 9 || ( event.keyDown.charScan.charCode >= 32 && event.keyDown.charScan.charCode < 255 ) ) { lock(); if( overwrite == True && hasSelection() == False ) if( curPtr != lineEnd(curPtr) ) selEnd = nextChar(curPtr); insertText( &event.keyDown.charScan.charCode, 1, False); trackCursor(centerCursor); unlock(); } else return; break; case evCommand: switch( event.message.command ) { case cmFind: find(); break; case cmReplace: replace(); break; case cmSearchAgain: doSearchReplace(); break; default: lock(); switch( event.message.command ) { case cmCut: clipCut(); break; case cmCopy: clipCopy(); // hideSelect(); // JS 12.4.94 break; case cmPaste: clipPaste(); break; case cmUndo: undo(); break; case cmClear: deleteSelect(); break; case cmCharLeft: setCurPtr(prevChar(curPtr), selectMode); break; case cmCharRight: setCurPtr(nextChar(curPtr), selectMode); break; case cmWordLeft: setCurPtr(prevWord(curPtr), selectMode); break; case cmWordRight: setCurPtr(nextWord(curPtr), selectMode); break; case cmLineStart: setCurPtr(lineStart(curPtr), selectMode); break; case cmLineEnd: setCurPtr(lineEnd(curPtr), selectMode); break; case cmLineUp: setCurPtr(lineMove(curPtr, -1), selectMode); break; case cmLineDown: setCurPtr(lineMove(curPtr, 1), selectMode); break; case cmPageUp: setCurPtr(lineMove(curPtr, -(size.y-1)), selectMode); break; case cmPageDown: setCurPtr(lineMove(curPtr, size.y-1), selectMode); break; case cmTextStart: setCurPtr(0, selectMode); break; case cmTextEnd: setCurPtr(bufLen, selectMode); break; case cmNewLine: newLine(); break; case cmBackSpace: deleteRange(prevChar(curPtr), curPtr, True); break; case cmDelChar: deleteRange(curPtr, nextChar(curPtr), True); break; case cmDelWord: deleteRange(curPtr, nextWord(curPtr), False); break; case cmDelStart: deleteRange(lineStart(curPtr), curPtr, False); break; case cmDelEnd: deleteRange(curPtr, lineEnd(curPtr), False); break; case cmDelLine: deleteRange(lineStart(curPtr), nextLine(curPtr), False); break; case cmInsMode: toggleInsMode(); break; case cmStartSelect: startSelect(); break; case cmHideSelect: hideSelect(); break; case cmIndentMode: autoIndent = Boolean(!autoIndent); break; default: unlock(); return; } trackCursor(centerCursor); unlock(); break; } case evBroadcast: switch( event.message.command ) { case cmScrollBarChanged: checkScrollBar( event, hScrollBar, delta.x ); checkScrollBar( event, vScrollBar, delta.y ); break; default: return; } } clearEvent(event); }
void deleteAndClear(Container& c) { deleteRange(c.begin(), c.end()); c.clear(); }
void deleteRange(Container const& c) { deleteRange(c.begin(), c.end()); }
int rfx_remove_range(time_t fromTime, uvast fromNode, uvast toNode) { Sdr sdr = getIonsdr(); PsmPartition ionwm = getIonwm(); IonVdb *vdb = getIonVdb(); IonRXref arg; PsmAddress rxelt; PsmAddress nextElt; PsmAddress rxaddr; IonRXref *rxref; /* Note: when the fromTime passed to ionadmin is '*' * a fromTime of zero is passed to rfx_remove_range, * where it is interpreted as "all ranges between * these two nodes". */ memset((char *) &arg, 0, sizeof(IonRXref)); arg.fromNode = fromNode; arg.toNode = toNode; CHKERR(sdr_begin_xn(sdr)); if (fromTime) /* Not a wild-card deletion. */ { arg.fromTime = fromTime; rxelt = sm_rbt_search(ionwm, vdb->rangeIndex, rfx_order_ranges, &arg, &nextElt); if (rxelt) /* Found it. */ { rxaddr = sm_rbt_data(ionwm, rxelt); deleteRange(rxaddr, 0); } } else /* Wild-card deletion, start at time zero. */ { while (1) { /* Get first remaining range for this * to/from node pair. */ oK(sm_rbt_search(ionwm, vdb->rangeIndex, rfx_order_ranges, &arg, &rxelt)); if (rxelt == 0) { break; /* No more ranges. */ } rxaddr = sm_rbt_data(ionwm, rxelt); rxref = (IonRXref *) psp(ionwm, rxaddr); if (rxref->fromNode > arg.fromNode || rxref->toNode > arg.toNode) { break; /* No more matches. */ } deleteRange(rxaddr, 0); } } if (fromNode > toNode) { /* This is either an imputed range or else * a non-canonical range assertion, * indicating an override of the normal * symmetry in the owlt between nodes. The * reverse range assertion does *not* hold. */ if (sdr_end_xn(sdr) < 0) { putErrmsg("Can't remove range(s).", NULL); return -1; } return 0; } /* Canonical range assertion(s); delete corresponding * imputed range(s) as well. */ arg.fromNode = toNode; /* Reverse direction. */ arg.toNode = fromNode; /* Reverse direction. */ if (fromTime) /* Not a wild-card deletion. */ { arg.fromTime = fromTime; rxelt = sm_rbt_search(ionwm, vdb->rangeIndex, rfx_order_ranges, &arg, &nextElt); if (rxelt) /* Found it. */ { rxaddr = sm_rbt_data(ionwm, rxelt); deleteRange(rxaddr, 1); } } else /* Wild-card deletion, start at time zero. */ { while (1) { /* Get first remaining range for this * to/from node pair. */ oK(sm_rbt_search(ionwm, vdb->rangeIndex, rfx_order_ranges, &arg, &rxelt)); if (rxelt == 0) { break; /* No more ranges. */ } rxaddr = sm_rbt_data(ionwm, rxelt); rxref = (IonRXref *) psp(ionwm, rxaddr); if (rxref->fromNode > arg.fromNode || rxref->toNode > arg.toNode) { break; /* No more matches. */ } deleteRange(rxaddr, 1); } } if (sdr_end_xn(sdr) < 0) { putErrmsg("Can't remove range(s).", NULL); return -1; } return 0; }
bool RangeDeleter::deleteNow(OperationContext* txn, const std::string& ns, const BSONObj& min, const BSONObj& max, const BSONObj& shardKeyPattern, bool secondaryThrottle, string* errMsg) { if (stopRequested()) { *errMsg = "deleter is already stopped."; return false; } string dummy; if (errMsg == NULL) errMsg = &dummy; NSMinMax deleteRange(ns, min, max); { scoped_lock sl(_queueMutex); if (!canEnqueue_inlock(ns, min, max, errMsg)) { return false; } _deleteSet.insert(&deleteRange); // Note: count for pending deletes is an integral part of the shutdown story. // Therefore, to simplify things, there is no "pending" state for deletes in // deleteNow, the state transition is simply inProgress -> done. _deletesInProgress++; } set<CursorId> cursorsToWait; _env->getCursorIds(txn, ns, &cursorsToWait); long long checkIntervalMillis = 5; if (!cursorsToWait.empty()) { log() << "rangeDeleter waiting for " << cursorsToWait.size() << " cursors in " << ns << " to finish" << endl; } RangeDeleteEntry taskDetails(ns, min, max, shardKeyPattern, secondaryThrottle); taskDetails.stats.queueStartTS = jsTime(); Date_t timeSinceLastLog; for (; !cursorsToWait.empty(); sleepmillis(checkIntervalMillis)) { const unsigned long long timeNow = curTimeMillis64(); const unsigned long long elapsedTimeMillis = timeNow - taskDetails.stats.queueStartTS.millis; const unsigned long long lastLogMillis = timeNow - timeSinceLastLog.millis; if (elapsedTimeMillis > LogCursorsThresholdMillis && lastLogMillis > LogCursorsIntervalMillis) { timeSinceLastLog = jsTime(); logCursorsWaiting(ns, min, max, elapsedTimeMillis, cursorsToWait); } set<CursorId> cursorsNow; _env->getCursorIds(txn, ns, &cursorsNow); set<CursorId> cursorsLeft; std::set_intersection(cursorsToWait.begin(), cursorsToWait.end(), cursorsNow.begin(), cursorsNow.end(), std::inserter(cursorsLeft, cursorsLeft.end())); cursorsToWait.swap(cursorsLeft); if (stopRequested()) { *errMsg = "deleter was stopped."; scoped_lock sl(_queueMutex); _deleteSet.erase(&deleteRange); _deletesInProgress--; if (_deletesInProgress == 0) { _nothingInProgressCV.notify_one(); } return false; } if (checkIntervalMillis < MaxCurorCheckIntervalMillis) { checkIntervalMillis *= 2; } } taskDetails.stats.queueEndTS = jsTime(); ReplTime lastOp; taskDetails.stats.deleteStartTS = jsTime(); bool result = _env->deleteRange(txn, taskDetails, &taskDetails.stats.deletedDocCount, &lastOp, errMsg); taskDetails.stats.deleteEndTS = jsTime(); if (result) { taskDetails.stats.waitForReplStartTS = jsTime(); result = _env->waitForReplication(lastOp, DelWriteConcern, WaitForReplTimeoutSecs, errMsg); taskDetails.stats.waitForReplEndTS = jsTime(); } { scoped_lock sl(_queueMutex); _deleteSet.erase(&deleteRange); _deletesInProgress--; if (_deletesInProgress == 0) { _nothingInProgressCV.notify_one(); } } recordDelStats(new DeleteJobStats(taskDetails.stats)); return result; }