QueryResult TextQuery::query( const std::string& ac_sWord ) const { auto xCount = mc_Results.find( ac_sWord ); if ( xCount != mc_Results.end() ) return QueryResult(ac_sWord, mc_xLines, xCount->second); else return QueryResult(ac_sWord, mc_xLines, std::make_shared< std::set< mt_uLineNum > >() ); }
QueryResult Query::raycast_faces(Ray ray, QueryType queryType) { if (!boundary_faces){ rebuild_boundary_cache(); } FaceKey firstIntersection((unsigned int) -1); double dist = std::numeric_limits<double>::max(); for (auto faceIter : *boundary_faces){ Face & face = mesh->get(faceIter); auto nodePos = mesh->get_pos(face.node_keys()); double newDist; if (ray.intersect_triangle(nodePos[0], nodePos[1], nodePos[2], newDist)){ bool isFirstFoundTriangle = dist == std::numeric_limits<double>::max(); if (isFirstFoundTriangle){ firstIntersection = faceIter; dist = newDist; } else { if (newDist < dist){ firstIntersection = faceIter; dist = newDist; } break; } } } if ((unsigned int)firstIntersection == (unsigned int)-1){ return QueryResult(); } return QueryResult(firstIntersection, dist, ray, queryType, mesh); }
QueryResult TextQuery::query(const std::string &sought) const { static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>); auto loc = wm.find(sought); if (loc == wm.end()) return QueryResult(sought, nodata, file); else return QueryResult(sought, loc->second, file); }
QueryResult TextQuery::query(const string& str) const { // use static just allocate once. static shared_ptr<std::set<StrBlob::size_type>> nodate(new std::set<StrBlob::size_type>); auto found = result.find(str); if (found == result.end()) return QueryResult(str, nodate, input); else return QueryResult(str, found->second, input); }
QueryResult TextQuery::query(const string &s) const { static shared_ptr<set<string::size_type>> nodata(new set<string::size_type>); auto pos = wm.find(s); if(pos == wm.end()) return QueryResult(s,nodata,file); else return QueryResult(s,pos->second,file); }
QueryResult TextQuery::query(std::string s) { auto iter = wm.find(s); static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>); if(iter != wm.end()) return QueryResult(s, file, iter->second); else return QueryResult(s, file, nodata); }
const QueryResult TextQuery::query(const string &word) const { static shared_ptr<set<int>> nodata(new set<int>); auto loc = wm.find(word); if (loc != wm.end()) return QueryResult(word, loc->second, file); else return QueryResult(word, nodata, file); }
QueryResult TextQuery::query(const std::string& word) const { static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>); auto loc = lines_record.find(word); if (loc == lines_record.end()) { return QueryResult(word, nodata, text); } else { return QueryResult(word, loc->second, text); } }
QueryResult TextQuery::query(const std::string& sought) const { // we'll return a pointer to this std::set if we don't find sought static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>); //use find and not a subscript to avoid adding words to wm! auto loc = wm.find(sought); if(loc == wm.end()) return QueryResult(sought, nodata, file); // not found else return QueryResult(sought, loc->second, file); }
QueryResult SQLQueryHolder::GetResult(size_t index) { // Don't call to this function if the index is of an ad-hoc statement if (index < m_queries.size()) { ResultSet* result = m_queries[index].second.qresult; if (!result || !result->GetRowCount()) return QueryResult(NULL); result->NextRow(); return QueryResult(result); } else return QueryResult(NULL); }
QueryResult TextQuery::query(const std::string &s) const { std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>); auto it = word_map.find(s); if(it == word_map.end()) { return QueryResult(s, nodata, file); } else { return QueryResult(s, it->second, file); } }
/** * @brief do a query opertion and return QueryResult object. */ QueryResult TextQuery::query(const std::string &sought) const { //! dynamicaly allocated set used for the word does not appear. static std::shared_ptr<std::set<index_Tp>> noData(new std::set<index_Tp>); //! fetch the iterator to the matching element in the map<word, lines>. //std::map<std::string, std::shared_ptr<std::set<index_Tp>>>::const_iterator auto iter = wm.find(sought); if(iter == wm.end()) return QueryResult(sought, noData, file); else return QueryResult(sought, iter->second, file); }
QueryResult query(const std::string &word) const { // *TN* How to handle the case when not found? Use empty set rather // then nullptr since print() do not have to handle a special case. static auto notfound = std::make_shared<std::set<lineno>>(); // *TN* should not use [] since it can add a new one auto pos = word_map_.find(word); if (pos != word_map_.end()) return QueryResult(word, input_file_, pos->second); else return QueryResult(word, input_file_, notfound); }
/** * * Connects to the database * * Note that this expects that the database driver has setup all the things in * the connection. * * @return A QueryResult. error.isError will be false on success. */ QueryResult DatabaseConnection::connect() { QueryResult result; if (driver == nullptr) { // Get driver instance driver = get_driver_instance(); // Init SQL thread driver->threadInit(); } if (connection == nullptr) { try { connection = driver->connect(hostname, username, password); } catch (SQLException &e) { result.error.isError = true; result.error.code = e.getErrorCode(); result.error.string = e.getSQLState() + ": " + e.what(); return result; } // Reset result result = QueryResult(); // Get connection id result = this->execute(VariantVector() << "SELECT CONNECTION_ID()"); if (result.rows.size() == 0 || result.error.isError) { // No row returned return result; } connection_id = result.rows.front().front().toUInt(); // Reset result result = QueryResult(); return result; } // Successful connection? return result; }
QueryResult DatabaseWorkerPool<T>::Query(const char* sql, T* connection /*= nullptr*/) { if (!connection) connection = GetFreeConnection(); ResultSet* result = connection->Query(sql); connection->Unlock(); if (!result || !result->GetRowCount() || !result->NextRow()) { delete result; return QueryResult(NULL); } return QueryResult(result); }
int Dictionary::dict_find (ustring dictionaryname, ustring query) { int dindex = get_document_index (dictionaryname); if (dindex < 0) return dindex; ASSERT (dindex >= 0 && dindex < (int)m_documents.size()); Query q (dindex, 0, query); QueryMap::iterator qfound = m_cache.find (q); if (qfound != m_cache.end()) { return qfound->second.valueoffset; } pugi::xml_document *doc = m_documents[dindex]; // Query was not found. Do the expensive lookup and cache it pugi::xpath_node_set matches; try { matches = doc->select_nodes (query.c_str()); } catch (const pugi::xpath_exception& e) { m_context->error ("Invalid dict_find query '%s': %s", query.c_str(), e.what()); return 0; } if (matches.empty()) { m_cache[q] = QueryResult (false); // mark invalid return 0; // Not found } int firstmatch = (int) m_nodes.size(); int last = -1; for (int i = 0, e = (int)matches.size(); i < e; ++i) { m_nodes.push_back (Node (dindex, matches[i].node())); int nodeid = (int) m_nodes.size()-1; if (last < 0) { // If this is the first match, add a cache entry for it m_cache[q] = QueryResult (true /* it's a node */, nodeid); } else { // If this is a subsequent match, set the last match's 'next' m_nodes[last].next = nodeid; } last = nodeid; } return firstmatch; }
QueryResult AndQuery::eval(const TextQuery& text) const { auto left=lhs.eval(text), right=rhs.eval(text); auto ret_lines=std::make_shared<std::set<line_no>>(); set_intersection(left.begin(),left.end(),right.begin(),right.end(),inserter(*ret_lines,ret_lines->begin())); return QueryResult(rep(),ret_lines,left.get_file()); }
// returns the lines not in its operand's result set QueryResult NotQuery::eval(const TextQuery& text) const { // virtual call to eval through the Query operand auto result = query.eval(text); // start out with an empty result set auto ret_lines = std::make_shared<std::set<line_no>>(); // we have to iterate through the lines on which our operand appears auto beg = result.begin(), end = result.end(); // for each line in the input file, if that line is not in result, // add that line number to ret_lines auto sz = result.get_file()->size(); for (size_t n = 0; n != sz; ++n) { // if we haven't processed all the lines in result // check whether this line is present if (beg == end || *beg != n) ret_lines->insert(n); // if not in result, add this line else if (beg != end) ++beg; // otherwise get next line number in result if there is one } return QueryResult(rep(), ret_lines, result.get_file()); }
bool BasicStatementTask::Execute() { if(m_has_result) { ResultSet* result = m_conn->Query(m_sql); if(!result || !result->GetRowCount()) { m_result.set(QueryResult(NULL)); return false; } result->NextRow(); m_result.set(QueryResult(result)); return true; } return m_conn->Execute(m_sql); }
bool BasicStatementTask::Execute() { if (m_has_result) { ResultSet* result = m_conn->Query(m_sql); if (!result || !result->GetRowCount() || !result->NextRow()) { delete result; m_result->set_value(QueryResult(nullptr)); return false; } m_result->set_value(QueryResult(result)); return true; } return m_conn->Execute(m_sql); }
// ---------------------------------------------------------------------------- // CNATFWUNSAFQuerySrv::HandleQueryResultL // ---------------------------------------------------------------------------- // void CNATFWUNSAFQuerySrv::HandleQueryResultL( MNATFWUNSAFHostResolver& aResolver ) { if ( QueryResult().Target().CompareF( KDot8 ) != KErrNone ) { AddL( QueryResult() ); } while ( aResolver.Resolver().QueryGetNext( QueryResultBuf() ) == KErrNone ) { if ( QueryResult().Target().CompareF( KDot8 ) != KErrNone ) { //Records are sorted in right order in inserting phase AddL( QueryResult() ); } } }
// Deer Action. QueryResult DeerAction::query() { cout << " >> [~ Deer Action ~]: Enter the name of the player you wish to exchange your secret animal with." << endl; cout << " >> Name: "; string playerName = ""; getline(cin, playerName); QueryResult qr = QueryResult(); qr.append(playerName); return qr; }
int Dictionary::dict_find (int nodeID, ustring query) { if (nodeID <= 0 || nodeID >= (int)m_nodes.size()) return 0; // invalid node ID const Dictionary::Node &node (m_nodes[nodeID]); Query q (node.document, nodeID, query); QueryMap::iterator qfound = m_cache.find (q); if (qfound != m_cache.end()) { return qfound->second.valueoffset; } // Query was not found. Do the expensive lookup and cache it pugi::xpath_node_set matches; try { matches = node.node.select_nodes (query.c_str()); } catch (const pugi::xpath_exception& e) { m_context->error ("Invalid dict_find query '%s': %s", query.c_str(), e.what()); return 0; } if (matches.empty()) { m_cache[q] = QueryResult (false); // mark invalid return 0; // Not found } int firstmatch = (int) m_nodes.size(); int last = -1; for (int i = 0, e = (int)matches.size(); i < e; ++i) { m_nodes.push_back (Node (node.document, matches[i].node())); int nodeid = (int) m_nodes.size()-1; if (last < 0) { // If this is the first match, add a cache entry for it m_cache[q] = QueryResult (true /* it's a node */, nodeid); } else { // If this is a subsequent match, set the last match's 'next' m_nodes[last].next = nodeid; } last = nodeid; } return firstmatch; }
QueryResult OrQuery::eval(const TextQuery & tq) const { QueryResult left_result = lhs.eval(tq); QueryResult right_result = rhs.eval(tq); shared_ptr<set<size_t>> ret_lines = make_shared<set<size_t>>(left_result.begin(),left_result.end()); ret_lines->insert(right_result.begin(), right_result.end()); return QueryResult(BinaryQuery::rep(), ret_lines, left_result.get_file()); }
QueryResult OrQuery::eval(const TextQuery &t) const { auto left = lhs.eval(t); auto right = rhs.eval(t); auto ret_lines = std::make_shared<set<line_no>>(left.begin(), left.end()); ret_lines->insert(right.begin(), right.end()); return QueryResult(rep(), ret_lines, left.get_file()); }
// returns the intersection of its operands' result sets QueryResult AndQuery::eval(const TextQuery &text) const { // virtual calls through the Query operands to get result sets for the operands auto left = lhs.eval(text), right = rhs.eval(text); // set to hold the intersection of left and right auto ret_lines = std::make_shared<std::set<line_no>>(); // writes the intersection of two ranges to a destination iterator // destination iterator in this call adds elements to ret_lines std::set_intersection(left.begin(), left.end(), right.begin(), right.end(), std::inserter(*ret_lines, ret_lines->begin())); return QueryResult(rep(), ret_lines, left.get_file()); }
// returns the union of its operands' result sets QueryResult OrQuery::eval(const TextQuery &text) const { // virtual calls through Query members, lhs and rhs // the calls to eval return the QueryResult for each operand auto left = lhs.eval(text), right = rhs.eval(text); // copy the line numbers from the left-hand operand into the result set auto ret_lines = std::make_shared<std::set<line_no>>(left.begin(), left.end()); // insert lines from the right-hand operand ret_lines->insert(right.begin(), right.end()); // returns the new QueryResult representing the union of lhs and rhs return QueryResult(rep(), ret_lines, left.get_file()); }
QueryResult OrQuery::eval(const TextQuery &text) const { QueryResult right = rhs.eval(text), left= lhs.eval(text); //! copy the left-hand operand into the result set std::shared_ptr<std::set<line_no>> ret_lines = std::make_shared<std::set<line_no>>(left.begin(), left.end()); //! inert lines from the right-hand operand ret_lines->insert(right.begin(), right.end()); return QueryResult(rep(),ret_lines,left.get_file()); }
// Hare Action. QueryResult HareAction::query() { QueryResult qr = QueryResult(); cout << " >> [~ Hare Action ~]: Enter the coordinates 'x0,y0,x1,y1' of which card you want to move and where." << endl; cout << " >> Enter 'x0': "; string coordinate; getline(cin, coordinate); qr.append(coordinate); cout << " >> Enter 'y0': "; getline(cin, coordinate); qr.append(coordinate); cout << " >> Enter 'x1': "; getline(cin, coordinate); qr.append(coordinate); cout << " >> Enter 'y1': "; getline(cin, coordinate); qr.append(coordinate); return qr; }
QueryResult NotQuery::eval(const TextQuery& t) const { auto result = query.eval(t); // an empty set to store results auto ret_lines = std::make_shared<set<line_no>>(); // get the iterator auto beg = result.begin(), end = result.end(); auto sz = result.get_file()->size(); for(size_t n = 0; n != sz; ++n) { if(*beg != n || beg == end) ret_lines->insert(n); else if(beg != end) ++beg; } return QueryResult(rep(), ret_lines, result.get_file()); }