template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::iterator ACE_Unbounded_Set_Ex<T, C>::end (void) { // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::end"); return iterator (*this, 1); }
PointedThing ClientEnvironment::getPointedThing( core::line3d<f32> shootline, bool liquids_pointable, bool look_for_object) { PointedThing result; INodeDefManager *nodedef = m_map->getNodeDefManager(); core::aabbox3d<s16> maximal_exceed = nodedef->getSelectionBoxIntUnion(); // The code needs to search these nodes core::aabbox3d<s16> search_range(-maximal_exceed.MaxEdge, -maximal_exceed.MinEdge); // If a node is found, there might be a larger node behind. // To find it, we have to go further. s16 maximal_overcheck = std::max(abs(search_range.MinEdge.X), abs(search_range.MaxEdge.X)) + std::max(abs(search_range.MinEdge.Y), abs(search_range.MaxEdge.Y)) + std::max(abs(search_range.MinEdge.Z), abs(search_range.MaxEdge.Z)); const v3f original_vector = shootline.getVector(); const f32 original_length = original_vector.getLength(); f32 min_distance = original_length; // First try to find an active object if (look_for_object) { ClientActiveObject *selected_object = getSelectedActiveObject( shootline, &result.intersection_point, &result.intersection_normal); if (selected_object != NULL) { min_distance = (result.intersection_point - shootline.start).getLength(); result.type = POINTEDTHING_OBJECT; result.object_id = selected_object->getId(); } } // Reduce shootline if (original_length > 0) { shootline.end = shootline.start + shootline.getVector() / original_length * min_distance; } // Try to find a node that is closer than the selected active // object (if it exists). voxalgo::VoxelLineIterator iterator(shootline.start / BS, shootline.getVector() / BS); v3s16 oldnode = iterator.m_current_node_pos; // Indicates that a node was found. bool is_node_found = false; // If a node is found, it is possible that there's a node // behind it with a large nodebox, so continue the search. u16 node_foundcounter = 0; // If a node is found, this is the center of the // first nodebox the shootline meets. v3f found_boxcenter(0, 0, 0); // The untested nodes are in this range. core::aabbox3d<s16> new_nodes; while (true) { // Test the nodes around the current node in search_range. new_nodes = search_range; new_nodes.MinEdge += iterator.m_current_node_pos; new_nodes.MaxEdge += iterator.m_current_node_pos; // Only check new nodes v3s16 delta = iterator.m_current_node_pos - oldnode; if (delta.X > 0) new_nodes.MinEdge.X = new_nodes.MaxEdge.X; else if (delta.X < 0) new_nodes.MaxEdge.X = new_nodes.MinEdge.X; else if (delta.Y > 0) new_nodes.MinEdge.Y = new_nodes.MaxEdge.Y; else if (delta.Y < 0) new_nodes.MaxEdge.Y = new_nodes.MinEdge.Y; else if (delta.Z > 0) new_nodes.MinEdge.Z = new_nodes.MaxEdge.Z; else if (delta.Z < 0) new_nodes.MaxEdge.Z = new_nodes.MinEdge.Z; // For each untested node for (s16 x = new_nodes.MinEdge.X; x <= new_nodes.MaxEdge.X; x++) { for (s16 y = new_nodes.MinEdge.Y; y <= new_nodes.MaxEdge.Y; y++) { for (s16 z = new_nodes.MinEdge.Z; z <= new_nodes.MaxEdge.Z; z++) { MapNode n; v3s16 np(x, y, z); bool is_valid_position; n = m_map->getNodeNoEx(np, &is_valid_position); if (!(is_valid_position && isPointableNode(n, nodedef, liquids_pointable))) { continue; } std::vector<aabb3f> boxes; n.getSelectionBoxes(nodedef, &boxes, n.getNeighbors(np, m_map)); v3f npf = intToFloat(np, BS); for (std::vector<aabb3f>::const_iterator i = boxes.begin(); i != boxes.end(); ++i) { aabb3f box = *i; box.MinEdge += npf; box.MaxEdge += npf; v3f intersection_point; v3s16 intersection_normal; if (!boxLineCollision(box, shootline.start, shootline.getVector(), &intersection_point, &intersection_normal)) { continue; } f32 distance = (intersection_point - shootline.start).getLength(); if (distance >= min_distance) { continue; } result.type = POINTEDTHING_NODE; result.node_undersurface = np; result.intersection_point = intersection_point; result.intersection_normal = intersection_normal; found_boxcenter = box.getCenter(); min_distance = distance; is_node_found = true; } } } } if (is_node_found) { node_foundcounter++; if (node_foundcounter > maximal_overcheck) { break; } } // Next node if (iterator.hasNext()) { oldnode = iterator.m_current_node_pos; iterator.next(); } else { break; } } if (is_node_found) { // Set undersurface and abovesurface nodes f32 d = 0.002 * BS; v3f fake_intersection = result.intersection_point; // Move intersection towards its source block. if (fake_intersection.X < found_boxcenter.X) fake_intersection.X += d; else fake_intersection.X -= d; if (fake_intersection.Y < found_boxcenter.Y) fake_intersection.Y += d; else fake_intersection.Y -= d; if (fake_intersection.Z < found_boxcenter.Z) fake_intersection.Z += d; else fake_intersection.Z -= d; result.node_real_undersurface = floatToInt(fake_intersection, BS); result.node_abovesurface = result.node_real_undersurface + result.intersection_normal; } return result; }
static iterator end(unsigned int nb) { return iterator(nb, NULL); }
PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::iterator PB_DS_CLASS_C_DEC:: begin() { return iterator(m_p_head->m_p_min); }
int main() { StringIterator iterator("Hello world!\n"); hello_world(iterator); return 0; }
Status repairDatabase( string dbName, bool preserveClonedFilesOnFailure, bool backupOriginalFiles ) { scoped_ptr<RepairFileDeleter> repairFileDeleter; doingRepair dr; dbName = nsToDatabase( dbName ); log() << "repairDatabase " << dbName << endl; invariant( cc().database()->name() == dbName ); invariant( cc().database()->path() == storageGlobalParams.dbpath ); BackgroundOperation::assertNoBgOpInProgForDb(dbName); getDur().syncDataAndTruncateJournal(); // Must be done before and after repair intmax_t totalSize = dbSize( dbName ); intmax_t freeSize = File::freeSpace(storageGlobalParams.repairpath); if ( freeSize > -1 && freeSize < totalSize ) { return Status( ErrorCodes::OutOfDiskSpace, str::stream() << "Cannot repair database " << dbName << " having size: " << totalSize << " (bytes) because free disk space is: " << freeSize << " (bytes)" ); } killCurrentOp.checkForInterrupt(); Path reservedPath = uniqueReservedPath( ( preserveClonedFilesOnFailure || backupOriginalFiles ) ? "backup" : "_tmp" ); MONGO_ASSERT_ON_EXCEPTION( boost::filesystem::create_directory( reservedPath ) ); string reservedPathString = reservedPath.string(); if ( !preserveClonedFilesOnFailure ) repairFileDeleter.reset( new RepairFileDeleter( dbName, reservedPathString, reservedPath ) ); { Database* originalDatabase = dbHolder().get( dbName, storageGlobalParams.dbpath ); if ( originalDatabase == NULL ) return Status( ErrorCodes::NamespaceNotFound, "database does not exist to repair" ); Database* tempDatabase = NULL; { bool justCreated = false; tempDatabase = dbHolderW().getOrCreate( dbName, reservedPathString, justCreated ); invariant( justCreated ); } map<string,CollectionOptions> namespacesToCopy; { string ns = dbName + ".system.namespaces"; Client::Context ctx( ns ); Collection* coll = originalDatabase->getCollection( ns ); if ( coll ) { scoped_ptr<CollectionIterator> it( coll->getIterator( DiskLoc(), false, CollectionScanParams::FORWARD ) ); while ( !it->isEOF() ) { DiskLoc loc = it->getNext(); BSONObj obj = coll->docFor( loc ); string ns = obj["name"].String(); NamespaceString nss( ns ); if ( nss.isSystem() ) { if ( nss.isSystemDotIndexes() ) continue; if ( nss.coll() == "system.namespaces" ) continue; } if ( !nss.isNormal() ) continue; CollectionOptions options; if ( obj["options"].isABSONObj() ) { Status status = options.parse( obj["options"].Obj() ); if ( !status.isOK() ) return status; } namespacesToCopy[ns] = options; } } } for ( map<string,CollectionOptions>::const_iterator i = namespacesToCopy.begin(); i != namespacesToCopy.end(); ++i ) { string ns = i->first; CollectionOptions options = i->second; Collection* tempCollection = NULL; { Client::Context tempContext( ns, tempDatabase ); tempCollection = tempDatabase->createCollection( ns, options, true, false ); } Client::Context readContext( ns, originalDatabase ); Collection* originalCollection = originalDatabase->getCollection( ns ); invariant( originalCollection ); // data MultiIndexBlock indexBlock( tempCollection ); { vector<BSONObj> indexes; IndexCatalog::IndexIterator ii = originalCollection->getIndexCatalog()->getIndexIterator( false ); while ( ii.more() ) { IndexDescriptor* desc = ii.next(); indexes.push_back( desc->infoObj() ); } Client::Context tempContext( ns, tempDatabase ); Status status = indexBlock.init( indexes ); if ( !status.isOK() ) return status; } scoped_ptr<CollectionIterator> iterator( originalCollection->getIterator( DiskLoc(), false, CollectionScanParams::FORWARD ) ); while ( !iterator->isEOF() ) { DiskLoc loc = iterator->getNext(); invariant( !loc.isNull() ); BSONObj doc = originalCollection->docFor( loc ); Client::Context tempContext( ns, tempDatabase ); StatusWith<DiskLoc> result = tempCollection->insertDocument( doc, indexBlock ); if ( !result.isOK() ) return result.getStatus(); getDur().commitIfNeeded(); killCurrentOp.checkForInterrupt(false); } { Client::Context tempContext( ns, tempDatabase ); Status status = indexBlock.commit(); if ( !status.isOK() ) return status; } } getDur().syncDataAndTruncateJournal(); MongoFile::flushAll(true); // need both in case journaling is disabled killCurrentOp.checkForInterrupt(false); Client::Context tempContext( dbName, reservedPathString ); Database::closeDatabase( dbName, reservedPathString ); } Client::Context ctx( dbName ); Database::closeDatabase(dbName, storageGlobalParams.dbpath); if ( backupOriginalFiles ) { _renameForBackup( dbName, reservedPath ); } else { _deleteDataFiles( dbName ); MONGO_ASSERT_ON_EXCEPTION( boost::filesystem::create_directory(Path(storageGlobalParams.dbpath) / dbName)); } if ( repairFileDeleter.get() ) repairFileDeleter->success(); _replaceWithRecovered( dbName, reservedPathString.c_str() ); if ( !backupOriginalFiles ) MONGO_ASSERT_ON_EXCEPTION( boost::filesystem::remove_all( reservedPath ) ); return Status::OK(); }
iterator end() { return iterator(data_ + size_); }
iterator end() noexcept { return iterator(m_pools.end()); }
iterator begin() { return iterator(*this); }
bool search(const sm_type &sm_, iterator &iter_, iterator &end_, std::multimap<typename sm_type::id_type, token_vector> *prod_map_ = 0) { bool hit_ = false; iterator curr_ = iter_; iterator last_eoi_; // results_ and productions_ defined here so that // allocated memory can be reused. basic_match_results<sm_type> results_; token_vector productions_; end_ = iterator(); while (curr_ != end_) { if (prod_map_) { prod_map_->clear(); } results_.reset(curr_->id, sm_); productions_.clear(); while (results_.entry.action != accept && results_.entry.action != error) { details::next(sm_, curr_, results_, last_eoi_, productions_); } hit_ = results_.entry.action == accept; if (hit_) { if (prod_map_) { iterator again_(iter_->first, last_eoi_->first, iter_.sm()); results_.reset(iter_->id, sm_); productions_.clear(); details::parse(sm_, again_, results_, productions_, prod_map_); } end_ = curr_; break; } else if (last_eoi_->id != 0) { iterator again_(iter_->first, last_eoi_->first, iter_.sm()); results_.reset(iter_->id, sm_); productions_.clear(); hit_ = details::parse(sm_, again_, results_, productions_, prod_map_); if (hit_) { end_ = last_eoi_; break; } } ++iter_; curr_ = iter_; } return hit_; }
iterator begin() noexcept { return iterator(m_pools.begin()); }
PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::iterator PB_DS_CLASS_C_DEC:: end() { return iterator(m_a_entries + m_size); }
PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::iterator PB_DS_CLASS_C_DEC:: begin() { return iterator(m_a_entries); }
view::iterator view::end() const { return iterator(); }
iterator end() { return iterator(*this, -1); }
iterator begin() const { return empty()? iterator(): iterator(m_buckets); }
bool HarfBuzzShaper::setupHarfBuzzRun() { m_startIndexOfCurrentRun += m_numCharactersOfCurrentRun; // Iterate through the text to take the largest range that stays within // a single font. int endOfRunIndex = m_normalizedBufferLength - m_startIndexOfCurrentRun; SurrogatePairAwareTextIterator iterator(m_normalizedBuffer.get() + m_startIndexOfCurrentRun, 0, endOfRunIndex, endOfRunIndex); UChar32 character; unsigned clusterLength = 0; if (!iterator.consume(character, clusterLength)) return false; m_currentFontData = m_font->glyphDataForCharacter(character, false).fontData; UErrorCode errorCode = U_ZERO_ERROR; UScriptCode currentScript = uscript_getScript(character, &errorCode); if (U_FAILURE(errorCode)) return false; if (currentScript == USCRIPT_INHERITED) currentScript = USCRIPT_COMMON; for (iterator.advance(clusterLength); iterator.consume(character, clusterLength); iterator.advance(clusterLength)) { const SimpleFontData* nextFontData = m_font->glyphDataForCharacter(character, false).fontData; if (nextFontData != m_currentFontData) break; UScriptCode nextScript = uscript_getScript(character, &errorCode); if (U_FAILURE(errorCode)) return false; if (currentScript == nextScript || nextScript == USCRIPT_INHERITED || nextScript == USCRIPT_COMMON) continue; if (currentScript == USCRIPT_COMMON) currentScript = nextScript; else break; } m_numCharactersOfCurrentRun = iterator.currentCharacter(); if (!m_harfbuzzBuffer) { m_harfbuzzBuffer = hb_buffer_create(); hb_buffer_set_unicode_funcs(m_harfbuzzBuffer, hb_icu_get_unicode_funcs()); } else hb_buffer_reset(m_harfbuzzBuffer); hb_buffer_set_script(m_harfbuzzBuffer, hb_icu_script_to_script(currentScript)); // WebKit always sets direction to LTR during width calculation. // We only set direction when direction is explicitly set to RTL so that // preventng wrong width calculation. if (m_run.rtl()) hb_buffer_set_direction(m_harfbuzzBuffer, HB_DIRECTION_RTL); // Determine whether this run needs to be converted to small caps. // nextScriptRun() will always send us a run of the same case, because a // case change while in small-caps mode always results in different // FontData, so we only need to check the first character's case. if (m_font->isSmallCaps() && u_islower(m_normalizedBuffer[m_startIndexOfCurrentRun])) { String upperText = String(m_normalizedBuffer.get() + m_startIndexOfCurrentRun, m_numCharactersOfCurrentRun); upperText.makeUpper(); m_currentFontData = m_font->glyphDataForCharacter(upperText[0], false, SmallCapsVariant).fontData; hb_buffer_add_utf16(m_harfbuzzBuffer, upperText.characters(), m_numCharactersOfCurrentRun, 0, m_numCharactersOfCurrentRun); } else hb_buffer_add_utf16(m_harfbuzzBuffer, m_normalizedBuffer.get() + m_startIndexOfCurrentRun, m_numCharactersOfCurrentRun, 0, m_numCharactersOfCurrentRun); return true; }
iterator end() const { return iterator(); }
iterator begin() { return iterator(data_); }
set_of_chars::iterator set_of_chars::begin() const { return iterator( *this ) ; }
hero_map::iterator hero_map::begin() { size_t i = 0; return iterator(i, this); }
set_of_chars::iterator set_of_chars::end() const { return iterator() ; }
PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::iterator PB_DS_CLASS_C_DEC:: end() { return iterator(m_p_head); }
HandleStorage::iterator HandleStorage::end() { return iterator(persistentSlots_.end(), false, this); }
void LayerBase::drawWithOpenGL(const Region& clip, GLint textureName, const GGLSurface& t) const { const DisplayHardware& hw(graphicPlane(0).displayHardware()); const uint32_t fbHeight = hw.getHeight(); const State& s(drawingState()); // bind our texture validateTexture(textureName); glEnable(GL_TEXTURE_2D); // Dithering... if (s.flags & ISurfaceComposer::eLayerDither) { glEnable(GL_DITHER); } else { glDisable(GL_DITHER); } if (UNLIKELY(s.alpha < 0xFF)) { // We have an alpha-modulation. We need to modulate all // texture components by alpha because we're always using // premultiplied alpha. // If the texture doesn't have an alpha channel we can // use REPLACE and switch to non premultiplied alpha // blending (SRCA/ONE_MINUS_SRCA). GLenum env, src; if (needsBlending()) { env = GL_MODULATE; src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA; } else { env = GL_REPLACE; src = GL_SRC_ALPHA; } const GGLfixed alpha = (s.alpha << 16)/255; glColor4x(alpha, alpha, alpha, alpha); glEnable(GL_BLEND); glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA); glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, env); } else { glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glColor4x(0x10000, 0x10000, 0x10000, 0x10000); if (needsBlending()) { GLenum src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA; glEnable(GL_BLEND); glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA); } else { glDisable(GL_BLEND); } } if (UNLIKELY(transformed() || !(mFlags & DisplayHardware::DRAW_TEXTURE_EXTENSION) )) { //StopWatch watch("GL transformed"); Region::iterator iterator(clip); if (iterator) { // always use high-quality filtering with fast configurations bool fast = !(mFlags & DisplayHardware::SLOW_CONFIG); if (!fast && s.flags & ISurfaceComposer::eLayerFilter) { glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } const GLfixed texCoords[4][2] = { { 0, 0 }, { 0, 0x10000 }, { 0x10000, 0x10000 }, { 0x10000, 0 } }; glMatrixMode(GL_TEXTURE); glLoadIdentity(); if (!(mFlags & DisplayHardware::NPOT_EXTENSION)) { // find the smallest power-of-two that will accommodate our surface GLuint tw = 1 << (31 - clz(t.width)); GLuint th = 1 << (31 - clz(t.height)); if (tw < t.width) tw <<= 1; if (th < t.height) th <<= 1; // this divide should be relatively fast because it's // a power-of-two (optimized path in libgcc) GLfloat ws = GLfloat(t.width) /tw; GLfloat hs = GLfloat(t.height)/th; glScalef(ws, hs, 1.0f); } glEnableClientState(GL_TEXTURE_COORD_ARRAY); glVertexPointer(2, GL_FIXED, 0, mVertices); glTexCoordPointer(2, GL_FIXED, 0, texCoords); Rect r; while (iterator.iterate(&r)) { const GLint sy = fbHeight - (r.top + r.height()); glScissor(r.left, sy, r.width(), r.height()); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } if (!fast && s.flags & ISurfaceComposer::eLayerFilter) { glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } glDisableClientState(GL_TEXTURE_COORD_ARRAY); } } else { Region::iterator iterator(clip); if (iterator) { Rect r; GLint crop[4] = { 0, t.height, t.width, -t.height }; glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop); int x = tx(); int y = ty(); y = fbHeight - (y + t.height); while (iterator.iterate(&r)) { const GLint sy = fbHeight - (r.top + r.height()); glScissor(r.left, sy, r.width(), r.height()); glDrawTexiOES(x, y, 0, t.width, t.height); } } } }
HandleStorage::iterator HandleStorage::begin() { return iterator(localSlots_.begin(), true, this); }
bool ExtensionMethodCacheEntryExplodingIterator::MoveNext() { bool flag = m_overloadIterator.MoveNext(); while (flag || m_Queue.Count() > 0) { if (flag) { if (m_pSemantics->IsAccessible(m_overloadIterator.Current(), m_pContext)) { return true; } else { flag = m_overloadIterator.MoveNext(); } } else if (m_Queue.Count() > 0) { CacheEntryAndBool entry = m_Queue.PopOrDequeue(); if (entry.m_increasePrecedenceLevel) { m_precedenceLevel += 1; } ListValueIterator<CacheEntryAndRelativePrecedenceInfo, NorlsAllocWrapper> iterator(&entry.m_pCacheEntry->m_parentCacheEntries); bool first = true; unsigned long lastRelativePrecedenceLevel = 0; while (iterator.MoveNext()) { CacheEntryAndRelativePrecedenceInfo loopVar = iterator.Current(); m_Queue.PushOrEnqueue(CacheEntryAndBool(loopVar.m_pCacheEntry, first || lastRelativePrecedenceLevel != loopVar.m_relativePrecedenceInfo)); first = false; lastRelativePrecedenceLevel = loopVar.m_relativePrecedenceInfo; } if (entry.m_pCacheEntry->m_method) { BCSYM_Class * pClass = entry.m_pCacheEntry->m_method->GetContainingClass(); if (pClass->GetMainType()) { pClass = pClass->GetMainType(); } //Because a type may be imported into scope via multiple precedence levels //(say once via a type import and once via a namespace import, or once via a //source file import and once via a project-level import), it is possible to have //mulitple cache entries for the same class. We don't want to consider that //class twice in overload resolution, so we keep a set of the types //that we have seen already. if (! m_typeSet.Contains(pClass)) { if (m_pSemantics->IsAccessible(pClass, m_pContext)) { //Reset the extension method overload iterator //so that it will yield the overloads of the method stored in the cache entry. m_overloadIterator.Reset(entry.m_pCacheEntry->m_method,m_pSemantics); flag = m_overloadIterator.MoveNext(); } m_typeSet.Add(pClass); } else { flag = false; } } } else { Assume(false, L"This code should not be reachable!"); } } return false; }
iterator begin() { return iterator(*this, x2008_firstId); }
/// subtracts diff and returns the iterator iterator operator-(ptrdiff_t diff) { DEBUG_SINVARIANT(inRangeMinus(diff)); return iterator(mydeque, static_cast<size_t>(cur_pos + mydeque->q_size - diff) % mydeque->q_size); }
iterator end() { return iterator(xmls.end()); }