void TextBox::keyPressed(KeyEvent& keyEvent) { Key key = keyEvent.getKey(); if (key.getValue() == Key::LEFT) { --mCaretColumn; if (mCaretColumn < 0) { --mCaretRow; if (mCaretRow < 0) { mCaretRow = 0; mCaretColumn = 0; } else { mCaretColumn = mTextRows[mCaretRow].size(); } } } else if (key.getValue() == Key::RIGHT) { ++mCaretColumn; if (mCaretColumn > (int)mTextRows[mCaretRow].size()) { ++mCaretRow; if (mCaretRow >= (int)mTextRows.size()) { mCaretRow = mTextRows.size() - 1; if (mCaretRow < 0) { mCaretRow = 0; } mCaretColumn = mTextRows[mCaretRow].size(); } else { mCaretColumn = 0; } } } else if (key.getValue() == Key::DOWN) { setCaretRow(mCaretRow + 1); } else if (key.getValue() == Key::UP) { setCaretRow(mCaretRow - 1); } else if (key.getValue() == Key::HOME) { mCaretColumn = 0; } else if (key.getValue() == Key::END) { mCaretColumn = mTextRows[mCaretRow].size(); } else if (key.getValue() == Key::ENTER && mEditable) { mTextRows.insert(mTextRows.begin() + mCaretRow + 1, mTextRows[mCaretRow].substr(mCaretColumn, mTextRows[mCaretRow].size() - mCaretColumn)); mTextRows[mCaretRow].resize(mCaretColumn); ++mCaretRow; mCaretColumn = 0; } else if (key.getValue() == Key::BACKSPACE && mCaretColumn != 0 && mEditable) { wchar_t c = mTextRows[mCaretRow][mCaretColumn-1]; if(c < 128) { mTextRows[mCaretRow].erase(mCaretColumn - 1, 1); --mCaretColumn; } else { mTextRows[mCaretRow].erase(mCaretColumn - 3, 3); mCaretColumn -= 3; } } else if (key.getValue() == Key::BACKSPACE && mCaretColumn == 0 && mCaretRow != 0 && mEditable) { mCaretColumn = mTextRows[mCaretRow - 1].size(); mTextRows[mCaretRow - 1] += mTextRows[mCaretRow]; mTextRows.erase(mTextRows.begin() + mCaretRow); --mCaretRow; } // else if (key.getValue() == Key::DELETE // && mCaretColumn < (int)mTextRows[mCaretRow].size() // && mEditable) else if (key.getValue() == 1013 && mCaretColumn != 0 && mEditable) { mTextRows[mCaretRow].erase(mCaretColumn, 1); } else if (key.getValue() == 1013 && mCaretColumn == (int)mTextRows[mCaretRow].size() && mCaretRow < ((int)mTextRows.size() - 1) && mEditable) { mTextRows[mCaretRow] += mTextRows[mCaretRow + 1]; mTextRows.erase(mTextRows.begin() + mCaretRow + 1); } else if(key.getValue() == Key::PAGE_UP) { Widget* par = getParent(); if (par != NULL) { int rowsPerPage = par->getChildrenArea().height / getFont()->getHeight(); mCaretRow -= rowsPerPage; if (mCaretRow < 0) { mCaretRow = 0; } } } else if(key.getValue() == Key::PAGE_DOWN) { Widget* par = getParent(); if (par != NULL) { int rowsPerPage = par->getChildrenArea().height / getFont()->getHeight(); mCaretRow += rowsPerPage; if (mCaretRow >= (int)mTextRows.size()) { mCaretRow = mTextRows.size() - 1; } } } else if(key.getValue() == Key::TAB && mEditable) { mTextRows[mCaretRow].insert(mCaretColumn, std::string(" ")); mCaretColumn += 4; } else if (key.isCharacter() && mEditable) { mTextRows[mCaretRow].insert(mCaretColumn, std::string(1,(char)key.getValue())); ++mCaretColumn; } // ak add ime else if (key.isIME()) { char szImeChar[3]; if (key.getValue() < 128) { szImeChar[0]=(char)key.getValue(); szImeChar[1]='\0'; } else { szImeChar[0]=(char)(key.getValue()>>8); szImeChar[1]=(char)key.getValue(); szImeChar[2]='\0'; } mTextRows[mCaretRow].insert(mCaretColumn, szImeChar); ++mCaretColumn; }
void Statistic::getInfo(const Key& key, long& get, long& put) { string k = key.toString(); get = data[k].get; put = data[k].put; }
void Statistic::notifyPut(const Key& key) { string k = key.toString(); data[k].put++; }
void TextBox::keyPressed(KeyEvent& keyEvent) { Key key = keyEvent.getKey(); if (key.getValue() == Key::Left) mText->setCaretPosition(mText->getCaretPosition() - 1); else if (key.getValue() == Key::Right) mText->setCaretPosition(mText->getCaretPosition() + 1); else if (key.getValue() == Key::Down) mText->setCaretRow(mText->getCaretRow() + 1); else if (key.getValue() == Key::Up) mText->setCaretRow(mText->getCaretRow() - 1); else if (key.getValue() == Key::Home) mText->setCaretColumn(0); else if (key.getValue() == Key::End) mText->setCaretColumn(mText->getNumberOfCharacters(mText->getCaretRow())); else if (key.getValue() == Key::Enter && mEditable) mText->insert('\n'); else if (key.getValue() == Key::Backspace && mEditable) mText->remove(-1); else if (key.getValue() == Key::Delete && mEditable) mText->remove(1); else if(key.getValue() == Key::PageUp) { Widget* par = getParent(); if (par != NULL) { int rowsPerPage = par->getChildrenArea().height / getFont()->getHeight(); mText->setCaretRow(mText->getCaretRow() - rowsPerPage); } } else if(key.getValue() == Key::PageDown) { Widget* par = getParent(); if (par != NULL) { int rowsPerPage = par->getChildrenArea().height / getFont()->getHeight(); mText->setCaretRow(mText->getCaretRow() + rowsPerPage); } } else if(key.getValue() == Key::Tab && mEditable) { mText->insert(' '); mText->insert(' '); mText->insert(' '); mText->insert(' '); } else if (key.isCharacter() && mEditable) mText->insert(key.getValue()); adjustSize(); scrollToCaret(); keyEvent.consume(); }
/** * @brief This function will be called after the parser exits a value. * * @param text This variable contains the text stored in the value. */ void Driver::exitValue (string const & text) { Key key = parents.top (); key.setString (scalarToText (text)); keys.append (key); }
TEST (test, copy) { // cout << "testing copy meta" << std::endl; Key k ("user/metakey", KEY_META, "", "metavalue", KEY_META, "a", "a metavalue", KEY_META, "b", "b metavalue", KEY_META, "c", "c metavalue", KEY_END); Key c; c.copyMeta (k, "a"); succeed_if (k.getMeta<const ckdb::Key *> ("a") == c.getMeta<const ckdb::Key *> ("a"), "copy meta did not work"); c.copyMeta (k, ""); succeed_if (k.getMeta<const ckdb::Key *> ("") == c.getMeta<const ckdb::Key *> (""), "copy meta did not work"); k.setMeta<int> ("a", 420); succeed_if (k.getMeta<int> ("a") == 420, "could not get value set before"); c.copyMeta (k, "a"); succeed_if (c.getMeta<int> ("a") == 420, "could not get value copied before"); succeed_if (k.getMeta<const ckdb::Key *> ("a") == c.getMeta<const ckdb::Key *> ("a"), "copy meta did not work"); c.copyMeta (k, "a"); succeed_if (c.getMeta<int> ("a") == 420, "could not get value copied before (again)"); succeed_if (k.getMeta<const ckdb::Key *> ("a") == c.getMeta<const ckdb::Key *> ("a"), "copy meta did not work (again)"); Key d; Key meta; k.rewindMeta (); while ((meta = k.nextMeta ())) { d.copyMeta (k, meta.getName ()); } succeed_if (d.getMeta<std::string> ("a") == "420", "did not copy metavalue in the loop"); succeed_if (d.getMeta<const ckdb::Key *> ("a") == d.getMeta<const ckdb::Key *> ("a"), "copy meta did not work in the loop"); succeed_if (d.getMeta<std::string> ("") == "metavalue", "did not copy metavalue in the loop"); succeed_if (d.getMeta<const ckdb::Key *> ("") == d.getMeta<const ckdb::Key *> (""), "copy meta did not work in the loop"); succeed_if (d.getMeta<std::string> ("b") == "b metavalue", "did not copy metavalue in the loop"); succeed_if (d.getMeta<const ckdb::Key *> ("b") == d.getMeta<const ckdb::Key *> ("b"), "copy meta did not work in the loop"); succeed_if (d.getMeta<std::string> ("c") == "c metavalue", "did not copy metavalue in the loop"); succeed_if (d.getMeta<const ckdb::Key *> ("c") == d.getMeta<const ckdb::Key *> ("c"), "copy meta did not work in the loop"); }
constexpr inline bool operator >=(const Key& key1, const Key& key2) noexcept { return key1.asUint32() >= key2.asUint32(); }
void IDBCursor::Continue(JSContext* aCx, JS::Handle<JS::Value> aKey, ErrorResult &aRv) { AssertIsOnOwningThread(); if (!mTransaction->IsOpen()) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR); return; } if (!mHaveValue || mContinueCalled) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR); return; } Key key; aRv = key.SetFromJSVal(aCx, aKey); if (aRv.Failed()) { return; } if (!key.IsUnset()) { switch (mDirection) { case NEXT: case NEXT_UNIQUE: if (key <= mKey) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_DATA_ERR); return; } break; case PREV: case PREV_UNIQUE: if (key >= mKey) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_DATA_ERR); return; } break; default: MOZ_CRASH("Unknown direction type!"); } } mBackgroundActor->SendContinueInternal(ContinueParams(key)); mContinueCalled = true; #ifdef IDB_PROFILER_USE_MARKS if (mType == Type_ObjectStore || mType == Type_ObjectStoreKey) { IDB_PROFILER_MARK("IndexedDB Request %llu: " "database(%s).transaction(%s).objectStore(%s).cursor(%s)." "continue(%s)", "IDBRequest[%llu] MT IDBCursor.continue()", Request()->GetSerialNumber(), IDB_PROFILER_STRING(Transaction()->Database()), IDB_PROFILER_STRING(Transaction()), IDB_PROFILER_STRING(mSourceObjectStore), IDB_PROFILER_STRING(mDirection), key.IsUnset() ? "" : IDB_PROFILER_STRING(key)); } else { IDB_PROFILER_MARK("IndexedDB Request %llu: " "database(%s).transaction(%s).objectStore(%s).index(%s)." "cursor(%s).continue(%s)", "IDBRequest[%llu] MT IDBCursor.continue()", Request()->GetSerialNumber(), IDB_PROFILER_STRING(Transaction()->Database()), IDB_PROFILER_STRING(Transaction()), IDB_PROFILER_STRING(mSourceIndex->ObjectStore()), IDB_PROFILER_STRING(mSourceIndex), IDB_PROFILER_STRING(mDirection), key.IsUnset() ? "" : IDB_PROFILER_STRING(key)); } #endif }
bool KeyManager::LoadFromFile(std::string filename){ std::ifstream stream; stream.open(filename); if(!stream.is_open()) { return false; } std::string row; std::getline(stream, row, '\n'); if (*(row.end()-1) == '\r') { row.erase(row.end()-1); } if (*(row.begin()) == '\xef') { for(int i =0; i<3; i++) { row.erase(row.begin()); } } while (!stream.eof()) { while(row != "\xa7") { int x, y; std::stringstream ss(row); ss >> x >> y; sf::Color* color = new sf::Color; int c; ss >> c; color->r=c; ss >> c; color->g=c; ss >> c; color->b=c; Key* key = new Key(x, y, m_texture, color); m_keys.insert(std::make_pair(key->GetPickUpRadius(), key)); ltbl::Light_Point* glow = new ltbl::Light_Point(); glow->m_center = Vec2f(key->GetPickUpRadius()->getPosition().x, mp_lightSystem->m_viewAABB.GetDims().y - key->GetPickUpRadius()->getPosition().y); glow->m_radius = key->GetPickUpRadius()->getRadius(); glow->m_size = 1.0f; glow->m_color.r = static_cast<float>(color->r) / 255.0f; glow->m_color.g = static_cast<float>(color->g) / 255.0f; glow->m_color.b = static_cast<float>(color->b) / 255.0f; glow->m_intensity = 2.0f; glow->m_spreadAngle = ltbl::pifTimes2; glow->m_softSpreadAngle = 0.0f; glow->CalculateAABB(); mp_lightManager->AddLight(glow, key); //glow->SetAlwaysUpdate(false); std::getline(stream, row, '\n'); if (*(row.end()-1) == '\r') { row.erase(row.end()-1); } } std::getline(stream, row, '\n'); if (row == "") { break; } } return true; }
size_t HashKey(const Key& key) const { return key.HashValue(); }
int LsCommand::getDepth (Key const & key) { return std::distance (key.begin (), key.end ()); }
void Tree::insert(const Key &k, TID tid) { N *node = nullptr; N *nextNode = root; N *parentNode = nullptr; uint8_t parentKey, nodeKey = 0; uint32_t level = 0; while (true) { parentNode = node; parentKey = nodeKey; node = nextNode; uint32_t nextLevel = level; uint8_t nonMatchingKey; Prefix remainingPrefix; switch (checkPrefixPessimistic(node, k, nextLevel, nonMatchingKey, remainingPrefix, this->loadKey)) { // increases level case CheckPrefixPessimisticResult::NoMatch: { assert(nextLevel < k.getKeyLen()); //prevent duplicate key // 1) Create new node which will be parent of node, Set common prefix, level to this node auto newNode = new N4(node->getPrefix(), nextLevel - level); // 2) add node and (tid, *k) as children newNode->insert(k[nextLevel], N::setLeaf(tid)); newNode->insert(nonMatchingKey, node); // 3) update parentNode to point to the new node N::change(parentNode, parentKey, newNode); // 4) update prefix of node node->setPrefix(remainingPrefix, node->getPrefixLength() - ((nextLevel - level) + 1)); return; } case CheckPrefixPessimisticResult::Match: break; } assert(nextLevel < k.getKeyLen()); //prevent duplicate key level = nextLevel; nodeKey = k[level]; nextNode = N::getChild(nodeKey, node); if (nextNode == nullptr) { N::insertA(node, parentNode, parentKey, nodeKey, N::setLeaf(tid)); return; } if (N::isLeaf(nextNode)) { Key key; loadKey(N::getLeaf(nextNode), key); level++; assert(level < key.getKeyLen()); //prevent inserting when prefix of key exists already uint32_t prefixLength = 0; while (key[level + prefixLength] == k[level + prefixLength]) { prefixLength++; } auto n4 = new N4(&k[level], prefixLength); n4->insert(k[level + prefixLength], N::setLeaf(tid)); n4->insert(key[level + prefixLength], nextNode); N::change(node, k[level - 1], n4); return; } level++; } }
void KeyboardShortcuts::importFile(TiXmlElement* rootElement, KeySource source) { // <keyboard><commands><key> TiXmlHandle handle(rootElement); TiXmlElement* xmlKey = handle .FirstChild("commands") .FirstChild("key").ToElement(); while (xmlKey) { const char* command_name = xmlKey->Attribute("command"); const char* command_key = get_shortcut(xmlKey); bool removed = bool_attr_is_true(xmlKey, "removed"); if (command_name) { Command* command = CommandsModule::instance()->getCommandByName(command_name); if (command) { // Read context KeyContext keycontext = KeyContext::Any; const char* keycontextstr = xmlKey->Attribute("context"); if (keycontextstr) { if (strcmp(keycontextstr, "Selection") == 0) keycontext = KeyContext::SelectionTool; else if (strcmp(keycontextstr, "Normal") == 0) keycontext = KeyContext::Normal; } // Read params Params params; TiXmlElement* xmlParam = xmlKey->FirstChildElement("param"); while (xmlParam) { const char* param_name = xmlParam->Attribute("name"); const char* param_value = xmlParam->Attribute("value"); if (param_name && param_value) params.set(param_name, param_value); xmlParam = xmlParam->NextSiblingElement(); } // add the keyboard shortcut to the command Key* key = this->command(command_name, params, keycontext); if (key && command_key) { Accelerator accel(command_key); if (!removed) { key->add(accel, source); // Add the shortcut to the menuitems with this command // (this is only visual, the // "CustomizedGuiManager::onProcessMessage" is the only // one that process keyboard shortcuts) if (key->accels().size() == 1) { AppMenus::instance()->applyShortcutToMenuitemsWithCommand( command, params, key); } } else key->disableAccel(accel); } } } xmlKey = xmlKey->NextSiblingElement(); } // Load keyboard shortcuts for tools // <gui><keyboard><tools><key> xmlKey = handle .FirstChild("tools") .FirstChild("key").ToElement(); while (xmlKey) { const char* tool_id = xmlKey->Attribute("tool"); const char* tool_key = get_shortcut(xmlKey); bool removed = bool_attr_is_true(xmlKey, "removed"); if (tool_id) { tools::Tool* tool = App::instance()->toolBox()->getToolById(tool_id); if (tool) { Key* key = this->tool(tool); if (key && tool_key) { LOG(" - Shortcut for tool `%s': <%s>\n", tool_id, tool_key); Accelerator accel(tool_key); if (!removed) key->add(accel, source); else key->disableAccel(accel); } } } xmlKey = xmlKey->NextSiblingElement(); } // Load keyboard shortcuts for quicktools // <gui><keyboard><quicktools><key> xmlKey = handle .FirstChild("quicktools") .FirstChild("key").ToElement(); while (xmlKey) { const char* tool_id = xmlKey->Attribute("tool"); const char* tool_key = get_shortcut(xmlKey); bool removed = bool_attr_is_true(xmlKey, "removed"); if (tool_id) { tools::Tool* tool = App::instance()->toolBox()->getToolById(tool_id); if (tool) { Key* key = this->quicktool(tool); if (key && tool_key) { LOG(" - Shortcut for quicktool `%s': <%s>\n", tool_id, tool_key); Accelerator accel(tool_key); if (!removed) key->add(accel, source); else key->disableAccel(accel); } } } xmlKey = xmlKey->NextSiblingElement(); } // Load special keyboard shortcuts for sprite editor customization // <gui><keyboard><spriteeditor> xmlKey = handle .FirstChild("actions") .FirstChild("key").ToElement(); while (xmlKey) { const char* tool_action = xmlKey->Attribute("action"); const char* tool_key = get_shortcut(xmlKey); bool removed = bool_attr_is_true(xmlKey, "removed"); if (tool_action) { KeyAction action = base::convert_to<KeyAction, std::string>(tool_action); if (action != KeyAction::None) { Key* key = this->action(action); if (key && tool_key) { LOG(" - Shortcut for action '%s': <%s>\n", tool_action, tool_key); Accelerator accel(tool_key); if (!removed) key->add(accel, source); else key->disableAccel(accel); } } } xmlKey = xmlKey->NextSiblingElement(); } }
// Manager event handler. bool CustomizedGuiManager::onProcessMessage(Message* msg) { switch (msg->type()) { case kCloseDisplayMessage: { // Execute the "Exit" command. Command* command = CommandsModule::instance()->getCommandByName(CommandId::Exit); UIContext::instance()->executeCommand(command); } break; case kDropFilesMessage: { // If the main window is not the current foreground one. We // discard the drop-files event. if (getForegroundWindow() != App::instance()->getMainWindow()) break; const DropFilesMessage::Files& files = static_cast<DropFilesMessage*>(msg)->files(); // Open all files Command* cmd_open_file = CommandsModule::instance()->getCommandByName(CommandId::OpenFile); Params params; UIContext* ctx = UIContext::instance(); for (const auto& fn : files) { // If the document is already open, select it. Document* doc = static_cast<Document*>(ctx->documents().getByFileName(fn)); if (doc) { DocumentView* docView = ctx->getFirstDocumentView(doc); if (docView) ctx->setActiveView(docView); else { ASSERT(false); // Must be some DocumentView available } } // Load the file else { params.set("filename", fn.c_str()); ctx->executeCommand(cmd_open_file, params); } } } break; case kKeyDownMessage: { #ifdef _DEBUG // Left Shift+Ctrl+Q generates a crash (useful to test the anticrash feature) if (msg->ctrlPressed() && msg->shiftPressed() && static_cast<KeyMessage*>(msg)->scancode() == kKeyQ) { int* p = nullptr; *p = 0; } #endif // Call base impl to check if there is a foreground window as // top level that needs keys. (In this way we just do not // process keyboard shortcuts for menus and tools). if (Manager::onProcessMessage(msg)) return true; for (const Key* key : *KeyboardShortcuts::instance()) { if (key->isPressed(msg)) { // Cancel menu-bar loops (to close any popup menu) App::instance()->getMainWindow()->getMenuBar()->cancelMenuLoop(); switch (key->type()) { case KeyType::Tool: { tools::Tool* current_tool = App::instance()->activeTool(); tools::Tool* select_this_tool = key->tool(); tools::ToolBox* toolbox = App::instance()->getToolBox(); std::vector<tools::Tool*> possibles; // Collect all tools with the pressed keyboard-shortcut for (tools::Tool* tool : *toolbox) { Key* key = KeyboardShortcuts::instance()->tool(tool); if (key && key->isPressed(msg)) possibles.push_back(tool); } if (possibles.size() >= 2) { bool done = false; for (size_t i=0; i<possibles.size(); ++i) { if (possibles[i] != current_tool && ToolBar::instance()->isToolVisible(possibles[i])) { select_this_tool = possibles[i]; done = true; break; } } if (!done) { for (size_t i=0; i<possibles.size(); ++i) { // If one of the possibilities is the current tool if (possibles[i] == current_tool) { // We select the next tool in the possibilities select_this_tool = possibles[(i+1) % possibles.size()]; break; } } } } ToolBar::instance()->selectTool(select_this_tool); return true; } case KeyType::Command: { Command* command = key->command(); // Commands are executed only when the main window is // the current window running at foreground. for (auto childWidget : children()) { Window* child = static_cast<Window*>(childWidget); // There are a foreground window executing? if (child->isForeground()) { break; } // Is it the desktop and the top-window= else if (child->isDesktop() && child == App::instance()->getMainWindow()) { // OK, so we can execute the command represented // by the pressed-key in the message... UIContext::instance()->executeCommand( command, key->params()); return true; } } break; } case KeyType::Quicktool: { // Do nothing, it is used in the editor through the // KeyboardShortcuts::getCurrentQuicktool() function. break; } } break; } } break; } case kTimerMessage: if (static_cast<TimerMessage*>(msg)->timer() == defered_invalid_timer) { invalidateDisplayRegion(defered_invalid_region); defered_invalid_region.clear(); defered_invalid_timer->stop(); } break; } return Manager::onProcessMessage(msg); }
void TextField::keyPressed(KeyEvent& keyEvent) { Key key = keyEvent.getKey(); if (key.getValue() == Key::Left) mText->setCaretPosition(mText->getCaretPosition() - 1); else if (key.getValue() == Key::Right) mText->setCaretPosition(mText->getCaretPosition() + 1); else if (key.getValue() == Key::Delete && mEditable) mText->remove(1); else if (key.getValue() == Key::Backspace && mEditable) mText->remove(-1); else if (key.getValue() == Key::Enter) distributeActionEvent(); else if (key.getValue() == Key::Home) mText->setCaretColumn(0); else if (key.getValue() == Key::End) mText->setCaretColumn(mText->getNumberOfCharacters(0)); else if (key.isCharacter() && key.getValue() != Key::Tab && mEditable) mText->insert(key.getValue()); if (key.getValue() != Key::Tab) keyEvent.consume(); fixScroll(); }
void IDBCursor::Continue(JSContext* aCx, JS::Handle<JS::Value> aKey, ErrorResult &aRv) { AssertIsOnOwningThread(); if (!mTransaction->IsOpen()) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR); return; } if (IsSourceDeleted() || !mHaveValue || mContinueCalled) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR); return; } Key key; aRv = key.SetFromJSVal(aCx, aKey); if (aRv.Failed()) { return; } if (!key.IsUnset()) { switch (mDirection) { case NEXT: case NEXT_UNIQUE: if (key <= mKey) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_DATA_ERR); return; } break; case PREV: case PREV_UNIQUE: if (key >= mKey) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_DATA_ERR); return; } break; default: MOZ_CRASH("Unknown direction type!"); } } const uint64_t requestSerialNumber = IDBRequest::NextSerialNumber(); mRequest->SetLoggingSerialNumber(requestSerialNumber); if (mType == Type_ObjectStore || mType == Type_ObjectStoreKey) { IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: " "database(%s).transaction(%s).objectStore(%s)." "cursor(%s).continue(%s)", "IndexedDB %s: C T[%lld] R[%llu]: IDBCursor.continue()", IDB_LOG_ID_STRING(), mTransaction->LoggingSerialNumber(), requestSerialNumber, IDB_LOG_STRINGIFY(mTransaction->Database()), IDB_LOG_STRINGIFY(mTransaction), IDB_LOG_STRINGIFY(mSourceObjectStore), IDB_LOG_STRINGIFY(mDirection), IDB_LOG_STRINGIFY(key)); } else { IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: " "database(%s).transaction(%s).objectStore(%s)." "index(%s).cursor(%s).continue(%s)", "IndexedDB %s: C T[%lld] R[%llu]: IDBCursor.continue()", IDB_LOG_ID_STRING(), mTransaction->LoggingSerialNumber(), requestSerialNumber, IDB_LOG_STRINGIFY(mTransaction->Database()), IDB_LOG_STRINGIFY(mTransaction), IDB_LOG_STRINGIFY(mSourceIndex->ObjectStore()), IDB_LOG_STRINGIFY(mSourceIndex), IDB_LOG_STRINGIFY(mDirection), IDB_LOG_STRINGIFY(key)); } mBackgroundActor->SendContinueInternal(ContinueParams(key)); mContinueCalled = true; }
int main(int argc, char** argv) { if(argc < 2) { std::cout << "Usage: " << argv[0] << " listen_port [boostrap_host:port]" << std::endl; return EXIT_FAILURE; } srand(time(NULL)); DHT* dht = new DHT(NULL, StrToTyp<uint16_t>(argv[1])); pf_log.SetLoggedFlags("DESYNCH WARNING ERR INFO DHT", false); Scheduler::StartSchedulers(5); if(argc > 2) { Host host = hosts_list.DecodeHost(argv[2]); pf_log[W_INFO] << "Connecting to " << host; dht->GetChimera()->Join(host); } std::string s; while(std::getline(std::cin, s)) { std::string command_str = stringtok(s, " "); Key k; if(command_str.length() == 0) continue; switch(command_str[0]) { case 's': case 'S': pf_log[W_DHT] << dht->GetStorage()->GetStr(); break; case 'l': case 'L': pf_log[W_DHT] << dht->GetChimera()->GetRouting()->GetLeafset()->GetStr(); break; case 'r': case 'R': pf_log[W_DHT] << dht->GetChimera()->GetRouting()->GetRoutingTable()->GetStr(); break; case 'p': case 'P': k.MakeHash(s); pf_log[W_DHT] << "Publish " << s << " with key " << k; dht->Publish(k, s); break; case 'u': case 'U': k = stringtok(s, " "); pf_log[W_DHT] << "Unublish " << s << " with key " << k; dht->Unpublish(k, s); break; case 'g': case 'G': k = s; pf_log[W_DHT] << "Request data with key " << k; if(!dht->RequestData(k)) if(dht->GetStorage()->hasKey(k)) pf_log[W_DHT] << dht->GetStorage()->getInfo(k)->GetStr(); break; case 'q': case 'Q': return EXIT_SUCCESS; default: pf_log[W_ERR] << "Command not recognized."; } } return EXIT_SUCCESS; }
void SpecMountpointReader::processKey (Key const & ck) { Key k (ck); k.rewindMeta (); Key m; while ((m = k.nextMeta ())) { std::string const & cn = "config/needs"; if (startsWith (m.getName (), cn)) { Key bKey = m.dup (); bKey.setName ("user" + bKey.getName ().substr (cn.length ())); backendConfig.append (bKey); } else if (m.getName () == "infos/plugins") { bb.addPlugins (parseArguments (m.getString ())); } else if (m.getName () == "infos/needs") { bb.needPlugin (m.getString ()); } else if (m.getName () == "infos/recommends") { bb.recommendPlugin (m.getString ()); } else if (isToBeIgnored (m.getName ())) { } else { bb.needMetadata (m.getName ()); } } }
TEST (meta, basic) { // cout << "testing metainfo" << endl; Key test; succeed_if (test.hasMeta ("mode") == false, "has meta?"); succeed_if (test.getMeta<mode_t> ("mode") == 0, "not properly default constructed"); test.setMeta<mode_t> ("mode", 0775); succeed_if (test.hasMeta ("mode") == true, "has not meta even though set?"); succeed_if (test.getMeta<mode_t> ("mode") == 0775, "not correct default mode for dir"); test.setMeta<int> ("myint", 333); succeed_if (test.getMeta<int> ("myint") == 333, "could not set other meta"); test.setMeta<double> ("mydouble", 333.3); succeed_if (test.hasMeta ("mydouble"), "no metadata even though it was just set"); succeed_if (test.getMeta<double> ("mydouble") >= 333.2, "could not set other meta"); succeed_if (test.getMeta<double> ("mydouble") <= 333.4, "could not set other meta"); test.delMeta ("mydouble"); succeed_if (!test.hasMeta ("mydouble"), "metadata there even though it was just deleted"); test.setMeta<std::string> ("mystr", "str"); succeed_if (test.getMeta<std::string> ("mystr") == "str", "could not set other meta"); const ckdb::Key * cmeta = test.getMeta<const ckdb::Key *> ("mystr"); succeed_if (!strcmp (static_cast<const char *> (ckdb::keyValue (cmeta)), "str"), "could not set other meta"); const ckdb::Key * nmeta = test.getMeta<const ckdb::Key *> ("not available"); succeed_if (nmeta == nullptr, "not available metadata did not give a null pointer"); const Key meta = test.getMeta<const Key> ("mystr"); succeed_if (meta, "null key"); succeed_if (meta.getString () == "str", "could not get other meta"); const Key xmeta = test.getMeta<const Key> ("not available"); succeed_if (!xmeta, "not a null key"); const char * str = test.getMeta<const char *> ("mystr"); succeed_if (!strcmp (str, "str"), "could not get meta as c-string"); const char * nstr = test.getMeta<const char *> ("not available"); succeed_if (nstr == nullptr, "did not get null pointer on not available metadata"); succeed_if (test.getMeta<int> ("not available") == 0, "not default constructed"); succeed_if (test.getMeta<std::string> ("not available") == "", "not default constructed"); test.setMeta<std::string> ("wrong", "not an int"); try { succeed_if (test.hasMeta ("wrong") == true, "meta is here"); test.getMeta<int> ("wrong"); succeed_if (0, "exception did not raise"); } catch (KeyTypeConversion const & e) { succeed_if (1, "no such metadata"); } }
bool keyMetaEqual (Key & k1, Key & k2) { if (!k1 || !k2) return false; k1.rewindMeta (); Key currentMeta; while ((currentMeta = k1.nextMeta ())) { string metaName = currentMeta.getName (); if (!k2.hasMeta (metaName)) return false; if (currentMeta.getString () != k2.getMeta<string> (metaName)) return false; } k2.rewindMeta (); while ((currentMeta = k2.nextMeta ())) { string metaName = currentMeta.getName (); if (!k1.hasMeta (metaName)) return false; if (currentMeta.getString () != k1.getMeta<string> (metaName)) return false; } return true; }
inline void Formatter(FormatData& formatData, const Key& key) { formatData.string.append(key.name()); }
w_rc_t key_ranges_map::addPartition(const Key& key, lpid_t& newRoot) { char* keyS = (char*) malloc(key.size()); key.copy_to(keyS); return (_addPartition(keyS, newRoot)); }
/** * This constructor creates a new driver for the given parent key. * * @param parent This key specifies the parent of the key set the parser * creates. */ Driver::Driver (Key const & parent) { parents.push (parent.dup ()); }
KeyQuaero::KeyQuaero(const Key& inKey) : Key(inKey.tonic(), ModeQuaero(inKey.mode())) { }
void InteractiveMergeStrategy::resolveConflict (const MergeTask & task, Key & conflictKey, MergeResult & result) { ConflictOperation ours = getOurConflictOperation (conflictKey); ConflictOperation theirs = getTheirConflictOperation (conflictKey); outputStream << "merging key " << conflictKey.getName () << endl; outputStream << endl; outputStream << "======== CONFLICT ========" << endl; outputStream << "our operation: " << MergeConflictOperation::getFromTag (ours) << endl; outputStream << "their operation: " << MergeConflictOperation::getFromTag (theirs) << endl; outputStream << endl; Key baseKey = task.base.lookup (rebasePath (conflictKey, task.mergeRoot, task.baseParent)); Key ourKey = task.ours.lookup (rebasePath (conflictKey, task.mergeRoot, task.ourParent)); Key theirKey = task.theirs.lookup (rebasePath (conflictKey, task.mergeRoot, task.theirParent)); outputStream << "======== KEY VALUES ========" << endl; outputKeyInfo ("base", baseKey, outputStream); outputKeyInfo ("ours", ourKey, outputStream); outputKeyInfo ("theirs", theirKey, outputStream); outputStream << endl; char choice; ConflictResolutionSide side; bool repeat; string input; do { outputStream << "What do you want to do?" << endl; outputStream << "Take [o]urs, [t]eirs, [b]ase, [m]erge meta: "; repeat = false; getline (inputStream, input); if (input.size () == 0 || input.size () > 1) { repeat = true; continue; } choice = input.at (0); switch (choice) { case 'o': side = OURS; outputStream << "Choose our key" << endl; break; case 't': side = THEIRS; outputStream << "Choose their key" << endl; break; case 'b': side = BASE; outputStream << "Choose base key" << endl; break; default: repeat = true; } } while (repeat); outputStream << endl; OneSideStrategy strategy (side); strategy.resolveConflict (task, conflictKey, result); outputStream << "Key merged..." << endl; }
inline bool ShapeHasher::match(const Key k, const Lookup &l) { return k->matches(l); }
void Statistic::notifyGet(const Key& key) { string k = key.toString(); data[k].get++; }
size_type operator() (const Key& key) const { return key.hash(); }
void key_at(size_t id, Key& key) const { memcpy(key.data__(), data_ + id * record_len_, key_len_); key.clean_msw(); }
/* Throws an exception if "key" is too short to be used. */ void RSA::checkKeyLength(const Key &key) { // Minimum required key length is around 24 bits. (In-house requirement) if (key.GetModulus().Length() < 8) throw "Error RSA01: Keys must be at least 8 digits long."; }