int be_visitor_valuetype_cdr_op_cs::visit_valuetype (be_valuetype *node) { // Already generated and/or we are imported. Don't do anything. if (node->cli_stub_cdr_op_gen () || node->imported () || ! node->is_defined ()) { return 0; } // Generate helper functions implementation. if (node->gen_helper_stubs () == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_valuetype_cdr_op_cs::" "visit_valuetype - " "codegen for helper functions failed\n"), -1); } TAO_OutStream *os = this->ctx_->stream (); node->cli_stub_cdr_op_gen (true); if (this->visit_scope (node) == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_valuetype_cdr_op_ci" "::visit_valuetype - " "codegen for scope failed\n"), -1); } *os << be_nl_2 << "// TAO_IDL - Generated from" << be_nl << "// " << __FILE__ << ":" << __LINE__ << be_nl_2; *os << be_global->core_versioning_begin () << be_nl; // Set the sub state as generating code for the output operator. this->ctx_->sub_state(TAO_CodeGen::TAO_CDR_OUTPUT); *os << "::CORBA::Boolean" << be_nl << "operator<< (" << be_idt << be_idt_nl << "TAO_OutputCDR &strm," << be_nl << "const " << node->full_name () << " *_tao_valuetype" << be_uidt_nl << ")" << be_uidt_nl << "{" << be_idt_nl; *os << "return" << be_idt_nl << "::CORBA::ValueBase::_tao_marshal (" << be_idt << be_idt_nl << "strm," << be_nl << "_tao_valuetype," << be_nl << "reinterpret_cast<ptrdiff_t> (&" << node->full_name () << "::_downcast)" << be_uidt_nl << ");" << be_uidt << be_uidt << be_uidt_nl << "}" << be_nl_2; *os << "::CORBA::Boolean" << be_nl << "operator>> (" << be_idt << be_idt_nl << "TAO_InputCDR &strm," << be_nl << node->full_name () << " *&_tao_valuetype" << be_uidt_nl << ")" << be_uidt_nl << "{" << be_idt_nl; *os << "return " << node->full_name () << "::_tao_unmarshal (strm, _tao_valuetype);" << be_uidt_nl << "}" << be_nl_2; if (be_global->gen_ostream_operators ()) { node->gen_ostream_operator (os, false); } *os << be_global->core_versioning_end () << be_nl; if (!node->is_abstract ()) { // Functions that marshal state. be_visitor_context new_ctx (*this->ctx_); be_visitor_valuetype_marshal_cs visitor (&new_ctx); visitor.visit_valuetype (node); } return 0; }
void SpatialAreaStore::getAreasForPosImpl(std::vector<Area *> *result, v3s16 pos) { VectorResultVisitor visitor(result, this); m_tree->pointLocationQuery(get_spatial_point(pos), visitor); }
Atoms get_charmm_untyped_atoms(Hierarchy hierarchy) { Atoms atoms; FindUntypedVisitor visitor(&atoms); IMP::core::visit_depth_first(hierarchy, visitor); return atoms; }
bool AssemblyLeafProbeVisitor::visit( const vector<UniqueID>& items, const vector<GAABB3>& bboxes, const size_t begin, const size_t end, const ShadingRay::RayType& ray, const ShadingRay::RayInfoType& /*ray_info*/, const double tmin, const double tmax, double& distance) { assert(begin + 1 == end); // Retrieve the assembly instance. const AssemblyInstance* assembly_instance = m_tree.m_scene.assembly_instances().get_by_uid(items[begin]); assert(assembly_instance); ShadingRay::RayType local_ray; local_ray.m_tmin = tmin; local_ray.m_tmax = tmax; // Transform the ray to assembly instance space. transform_ray_to_assembly_instance_space( assembly_instance, m_parent_shading_point, ray, local_ray); const RayInfo3d local_ray_info(local_ray); if (assembly_instance->get_assembly().is_flushable()) { // Retrieve the region tree of this assembly. const RegionTree& region_tree = *m_region_tree_cache.access( assembly_instance->get_assembly_uid(), m_tree.m_region_trees); // Check the intersection between the ray and the region tree. RegionLeafProbeVisitor visitor( m_triangle_tree_cache #ifdef FOUNDATION_BSP_ENABLE_TRAVERSAL_STATS , m_triangle_bsp_stats #endif ); RegionLeafProbeIntersector intersector; #ifdef FOUNDATION_BSP_ENABLE_TRAVERSAL_STATS bsp::TraversalStatistics stats; intersector.intersect( region_tree, local_ray, local_ray_info, visitor, stats); #else intersector.intersect( region_tree, local_ray, local_ray_info, visitor); #endif // Terminate traversal if there was a hit. if (visitor.hit()) { m_hit = true; return false; } } else { // Retrieve the triangle tree of this leaf. const TriangleTree* triangle_tree = m_triangle_tree_cache.access( assembly_instance->get_assembly_uid(), m_tree.m_triangle_trees); if (triangle_tree) { // Check the intersection between the ray and the triangle tree. TriangleLeafProbeVisitor visitor; TriangleLeafProbeIntersector intersector; intersector.intersect( *triangle_tree, local_ray, local_ray_info, visitor #ifdef FOUNDATION_BSP_ENABLE_TRAVERSAL_STATS , m_triangle_bsp_stats #endif ); // Terminate traversal if there was a hit. if (visitor.hit()) { m_hit = true; return false; } } } // Continue traversal. distance = ray.m_tmax; return true; }
bool LocationService::HandleAdminRegionLocation(const LocationSearch& search, const LocationSearch::Entry& searchEntry, const AdminRegionMatchVisitor::AdminRegionResult& adminRegionResult, const LocationMatchVisitor::LocationResult& locationResult, LocationSearchResult& result) const { if (searchEntry.addressPattern.empty()) { LocationSearchResult::Entry entry; entry.adminRegion=locationResult.adminRegion; entry.location=locationResult.location; if (adminRegionResult.isMatch) { entry.adminRegionMatchQuality=LocationSearchResult::match; } else { entry.adminRegionMatchQuality=LocationSearchResult::candidate; } if (locationResult.isMatch) { entry.locationMatchQuality=LocationSearchResult::match; } else { entry.locationMatchQuality=LocationSearchResult::candidate; } entry.poiMatchQuality=LocationSearchResult::none; entry.addressMatchQuality=LocationSearchResult::none; result.results.push_back(entry); return true; } //std::cout << " Search for address '" << searchEntry.addressPattern << "'" << std::endl; AddressMatchVisitor visitor(searchEntry.addressPattern, search.limit>=result.results.size() ? search.limit-result.results.size() : 0); if (!VisitLocationAddresses(*locationResult.adminRegion, *locationResult.location, visitor)) { log.Error() << "Error during traversal of region location address list"; return false; } if (visitor.results.empty()) { LocationSearchResult::Entry entry; entry.adminRegion=locationResult.adminRegion; entry.location=locationResult.location; if (adminRegionResult.isMatch) { entry.adminRegionMatchQuality=LocationSearchResult::match; } else { entry.adminRegionMatchQuality=LocationSearchResult::candidate; } if (locationResult.isMatch) { entry.locationMatchQuality=LocationSearchResult::match; } else { entry.locationMatchQuality=LocationSearchResult::candidate; } entry.poiMatchQuality=LocationSearchResult::none; entry.addressMatchQuality=LocationSearchResult::none; result.results.push_back(entry); return true; } for (const auto& addressResult : visitor.results) { //std::cout << " - '" << addressResult->address->name << "'" << std::endl; if (!HandleAdminRegionLocationAddress(search, adminRegionResult, locationResult, addressResult, result)) { return false; } } return true; }
static inline void apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry1, Geometry2 const& geometry2) { return boost::apply_visitor(visitor(geometry2), geometry1); }
QIcon StereotypeController::createIcon(StereotypeIcon::Element element, const QList<QString> &stereotypes, const QString &defaultIconPath, const Style *style, const QSize &size, const QMarginsF &margins, qreal lineWidth) { IconKey key(element, stereotypes, defaultIconPath, style->uid(), size, margins, lineWidth); QIcon icon = d->m_iconMap.value(key); if (!icon.isNull()) return icon; QString stereotypeIconId = findStereotypeIconId(element, stereotypes); if (!stereotypeIconId.isEmpty()) { StereotypeIcon stereotypeIcon = findStereotypeIcon(stereotypeIconId); // calculate bounding rectangle relativ to original icon size ShapeSizeVisitor sizeVisitor(QPointF(0.0, 0.0), QSizeF(stereotypeIcon.width(), stereotypeIcon.height()), QSizeF(stereotypeIcon.width(), stereotypeIcon.height()), QSizeF(stereotypeIcon.width(), stereotypeIcon.height())); stereotypeIcon.iconShape().visitShapes(&sizeVisitor); QRectF iconBoundingRect = sizeVisitor.boundingRect(); // calc painting space within margins qreal innerWidth = size.width() - margins.left() - margins.right(); qreal innerHeight = size.height() - margins.top() - margins.bottom(); // calculate width/height ratio from icon size qreal widthRatio = 1.0; qreal heightRatio = 1.0; qreal ratio = stereotypeIcon.width() / stereotypeIcon.height(); if (ratio > 1.0) heightRatio /= ratio; else widthRatio *= ratio; // calculate inner painting area qreal paintWidth = stereotypeIcon.width() * innerWidth / iconBoundingRect.width() * widthRatio; qreal paintHeight = stereotypeIcon.height() * innerHeight / iconBoundingRect.height() * heightRatio; // icons which renders smaller than their size should not be zoomed if (paintWidth > innerWidth) { paintHeight *= innerWidth / paintHeight; paintWidth = innerWidth; } if (paintHeight > innerHeight) { paintWidth *= innerHeight / paintHeight; paintHeight = innerHeight; } // calculate offset of top/left edge qreal paintLeft = iconBoundingRect.left() * paintWidth / stereotypeIcon.width(); qreal paintTop = iconBoundingRect.top() * paintHeight / stereotypeIcon.height(); // calculate total painting size qreal totalPaintWidth = iconBoundingRect.width() * paintWidth / stereotypeIcon.width(); qreal totalPaintHeight = iconBoundingRect.height() * paintHeight / stereotypeIcon.height(); QPixmap pixmap(size); pixmap.fill(Qt::transparent); QPainter painter(&pixmap); painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform); painter.setBrush(Qt::NoBrush); // set painting origin taking margin, offset and centering into account painter.translate(QPointF(margins.left(), margins.top()) - QPointF(paintLeft, paintTop) + QPointF((innerWidth - totalPaintWidth) / 2, (innerHeight - totalPaintHeight) / 2)); QPen linePen = style->linePen(); linePen.setWidthF(lineWidth); painter.setPen(linePen); painter.setBrush(style->fillBrush()); ShapePaintVisitor visitor(&painter, QPointF(0.0, 0.0), QSizeF(stereotypeIcon.width(), stereotypeIcon.height()), QSizeF(paintWidth, paintHeight), QSizeF(paintWidth, paintHeight)); stereotypeIcon.iconShape().visitShapes(&visitor); icon = QIcon(pixmap); } if (icon.isNull() && !defaultIconPath.isEmpty()) icon = QIcon(defaultIconPath); d->m_iconMap.insert(key, icon); return icon; }
int be_visitor_structure::visit_field (be_field *node) { // Instantiate a visitor context with a copy of our context. This info // will be modified based on what type of node we are visiting. be_visitor_context ctx (*this->ctx_); ctx.node (node); int status = 0; switch (this->ctx_->state ()) { case TAO_CodeGen::TAO_ROOT_CH: case TAO_CodeGen::TAO_INTERFACE_CH: case TAO_CodeGen::TAO_UNION_PUBLIC_CH: case TAO_CodeGen::TAO_UNION_PRIVATE_CH: case TAO_CodeGen::TAO_ARRAY_CH: { be_visitor_field_ch visitor (&ctx); status = node->accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CI: { be_visitor_field_ci visitor (&ctx); status = node->accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CS: case TAO_CodeGen::TAO_UNION_PUBLIC_CS: { be_visitor_field_cs visitor (&ctx); status = node->accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CDR_OP_CH: { be_visitor_field_cdr_op_ch visitor (&ctx); status = node->accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CDR_OP_CS: { be_visitor_field_cdr_op_cs visitor (&ctx); status = node->accept (&visitor); break; } default: { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_structure::" "visit_field - " "Bad context state\n"), -1); } } if (status == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_structure::" "visit_field - " "failed to accept visitor\n"), -1); } return 0; }
//! Distribute the budget based on the projected size and the primitive count of the child nodes in an iterative manner for correct distribution. static void distributeProjectedSizeAndPrimitiveCountIterative(double value, const Util::StringIdentifier & attributeId, Node * node, FrameContext & context) { static const Util::StringIdentifier primitiveCountId("PrimitiveCount"); struct PrimitiveCountAnnotationVisitor : public NodeVisitor { const Util::StringIdentifier & m_primitiveCountId; PrimitiveCountAnnotationVisitor(const Util::StringIdentifier & p_primitiveCountId) : m_primitiveCountId(p_primitiveCountId) { } virtual ~PrimitiveCountAnnotationVisitor() { } NodeVisitor::status leave(Node * _node) override { auto geoNode = dynamic_cast<GeometryNode *>(_node); uint32_t primitiveCount = 0; if(geoNode != nullptr) { const auto mesh = geoNode->getMesh(); primitiveCount = mesh == nullptr ? 0 : mesh->getPrimitiveCount(); } else { const auto children = getChildNodes(_node); for(const auto & child : children) { primitiveCount += child->getAttribute(m_primitiveCountId)->toUnsignedInt(); } } _node->setAttribute(m_primitiveCountId, Util::GenericAttribute::createNumber(primitiveCount)); return CONTINUE_TRAVERSAL; } }; const auto children = getChildNodes(node); // A pair stores the primitive count, the node and its projected size. std::deque<std::tuple<uint32_t, Node *, float>> primitiveCountNodeProjSizeTuples; double projSizeSum = 0.0; const Geometry::Rect_f screenRect(context.getRenderingContext().getWindowClientArea()); for(const auto & child : children) { if(!child->isAttributeSet(primitiveCountId)) { PrimitiveCountAnnotationVisitor visitor(primitiveCountId); child->traverse(visitor); } const auto primitiveCount = child->getAttribute(primitiveCountId)->toUnsignedInt(); // Clip the projected rect to the screen. auto projRect = context.getProjectedRect(child); projRect.clipBy(screenRect); const auto projSize = projRect.getArea(); projSizeSum += projSize; primitiveCountNodeProjSizeTuples.emplace_back(primitiveCount, child, projSize); } // Begin with the node with the lowest primitive count std::sort(primitiveCountNodeProjSizeTuples.begin(), primitiveCountNodeProjSizeTuples.end()); /* Distribute budget until one node gets all budget it asked for. * This means the previous distributions would receive more budget, * thus remove that node from distribution (update value and projSizeSum) * and start again. */ std::deque<std::tuple<uint32_t, Node *, float>> tmpDeque(primitiveCountNodeProjSizeTuples); // TODO: fails to copy values correctly!!! bool nodeRemoved; double tmpValue; double tmpProjSizeSum; double remainingProjSizeSum = projSizeSum; do{ nodeRemoved = false; tmpValue = value; tmpProjSizeSum = remainingProjSizeSum; for(auto it=tmpDeque.begin(); it!=tmpDeque.end(); ++it) { std::tuple<uint32_t, Node *, float> element = *it; const auto primitiveCount = std::get<0>(element); const auto projSize = std::get<2>(element); const auto projSizeFactor = projSize / tmpProjSizeSum; const auto primitiveAssignment = std::min(static_cast<uint32_t>(projSizeFactor * tmpValue), primitiveCount); setOrUpdateAttribute(std::get<1>(element), attributeId, primitiveAssignment); if(primitiveAssignment == primitiveCount){ nodeRemoved = true; tmpDeque.erase(it); value -= primitiveCount; remainingProjSizeSum -= projSize; break; } tmpValue -= primitiveAssignment; tmpProjSizeSum -= projSize; } }while(nodeRemoved); // distribute remaining part of value based on projected size only if(tmpValue >= 1){ for(const auto & primitiveCountNodeProjSizeTuple : primitiveCountNodeProjSizeTuples) { const auto projSize = std::get<2>(primitiveCountNodeProjSizeTuple); const auto projSizeFactor = projSize / projSizeSum; const auto attribute = dynamic_cast<Util::_NumberAttribute<double> *>(std::get<1>(primitiveCountNodeProjSizeTuple)->getAttribute(attributeId)); attribute->set(attribute->get() + projSizeFactor * tmpValue); } } }
typename graph_traits<Graph>::vertex_descriptor sloan_start_end_vertices(Graph& G, typename graph_traits<Graph>::vertex_descriptor &s, ColorMap color, DegreeMap degree) { typedef typename property_traits<DegreeMap>::value_type Degree; typedef typename graph_traits<Graph>::vertex_descriptor Vertex; typedef typename std::vector< typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter; typedef typename graph_traits<Graph>::vertices_size_type size_type; typedef typename property_map<Graph, vertex_index_t>::const_type VertexID; s = *(vertices(G).first); Vertex e = s; Vertex i; unsigned my_degree = get(degree, s ); unsigned dummy, h_i, h_s, w_i, w_e; bool new_start = true; unsigned maximum_degree = 0; //Creating a std-vector for storing the distance from the start vertex in dist std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(G), 0); //Wrap a property_map_iterator around the std::iterator boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, G)); //Creating a property_map for the indices of a vertex typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, G); //Creating a priority queue typedef indirect_cmp<DegreeMap, std::greater<Degree> > Compare; Compare comp(degree); std::priority_queue<Vertex, std::vector<Vertex>, Compare> degree_queue(comp); //step 1 //Scan for the vertex with the smallest degree and the maximum degree typename graph_traits<Graph>::vertex_iterator ui, ui_end; for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui) { dummy = get(degree, *ui); if(dummy < my_degree) { my_degree = dummy; s = *ui; } if(dummy > maximum_degree) { maximum_degree = dummy; } } //end 1 do{ new_start = false; //Setting the loop repetition status to false //step 2 //initialize the the disance std-vector with 0 for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0; //generating the RLS (rooted level structure) breadth_first_search (G, s, visitor ( make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) ) ); //end 2 //step 3 //calculating the depth of the RLS h_s = RLS_depth(dist); //step 4 //pushing one node of each degree in an ascending manner into degree_queue std::vector<bool> shrink_trace(maximum_degree, false); for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui) { dummy = get(degree, *ui); if( (dist[index_map[*ui]] == h_s ) && ( !shrink_trace[ dummy ] ) ) { degree_queue.push(*ui); shrink_trace[ dummy ] = true; } } //end 3 & 4 // step 5 // Initializing w w_e = (std::numeric_limits<unsigned>::max)(); //end 5 //step 6 //Testing for termination while( !degree_queue.empty() ) { i = degree_queue.top(); //getting the node with the lowest degree from the degree queue degree_queue.pop(); //ereasing the node with the lowest degree from the degree queue //generating a RLS for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0; breadth_first_search (G, i, boost::visitor ( make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) ) ); //Calculating depth and width of the rooted level h_i = RLS_depth(dist); w_i = RLS_max_width(dist, h_i); //Testing for termination if( (h_i > h_s) && (w_i < w_e) ) { h_s = h_i; s = i; while(!degree_queue.empty()) degree_queue.pop(); new_start = true; } else if(w_i < w_e) { w_e = w_i; e = i; } } //end 6 }while(new_start); return e; }
OutputIterator sloan_ordering(Graph& g, typename graph_traits<Graph>::vertex_descriptor s, typename graph_traits<Graph>::vertex_descriptor e, OutputIterator permutation, ColorMap color, DegreeMap degree, PriorityMap priority, Weight W1, Weight W2) { //typedef typename property_traits<DegreeMap>::value_type Degree; typedef typename property_traits<PriorityMap>::value_type Degree; typedef typename property_traits<ColorMap>::value_type ColorValue; typedef color_traits<ColorValue> Color; typedef typename graph_traits<Graph>::vertex_descriptor Vertex; typedef typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter; typedef typename graph_traits<Graph>::vertices_size_type size_type; typedef typename property_map<Graph, vertex_index_t>::const_type VertexID; //Creating a std-vector for storing the distance from the end vertex in it typename std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(g), 0); //Wrap a property_map_iterator around the std::iterator boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, g)); breadth_first_search (g, e, visitor ( make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) ) ); //Creating a property_map for the indices of a vertex typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, g); //Sets the color and priority to their initial status unsigned cdeg; typename graph_traits<Graph>::vertex_iterator ui, ui_end; for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { put(color, *ui, Color::white()); cdeg=get(degree, *ui)+1; put(priority, *ui, W1*dist[index_map[*ui]]-W2*cdeg ); } //Priority list typedef indirect_cmp<PriorityMap, std::greater<Degree> > Compare; Compare comp(priority); std::list<Vertex> priority_list; //Some more declarations typename graph_traits<Graph>::out_edge_iterator ei, ei_end, ei2, ei2_end; Vertex u, v, w; put(color, s, Color::green()); //Sets the color of the starting vertex to gray priority_list.push_front(s); //Puts s into the priority_list while ( !priority_list.empty() ) { priority_list.sort(comp); //Orders the elements in the priority list in an ascending manner u = priority_list.front(); //Accesses the last element in the priority list priority_list.pop_front(); //Removes the last element in the priority list if(get(color, u) == Color::green() ) { //for-loop over all out-edges of vertex u for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { v = target(*ei, g); put( priority, v, get(priority, v) + W2 ); //updates the priority if (get(color, v) == Color::white() ) //test if the vertex is inactive { put(color, v, Color::green() ); //giving the vertex a preactive status priority_list.push_front(v); //writing the vertex in the priority_queue } } } //Here starts step 8 *permutation++ = u; //Puts u to the first position in the permutation-vector put(color, u, Color::black() ); //Gives u an inactive status //for loop over all the adjacent vertices of u for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { v = target(*ei, g); if (get(color, v) == Color::green() ) { //tests if the vertex is inactive put(color, v, Color::red() ); //giving the vertex an active status put(priority, v, get(priority, v)+W2); //updates the priority //for loop over alll adjacent vertices of v for (boost::tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) { w = target(*ei2, g); if(get(color, w) != Color::black() ) { //tests if vertex is postactive put(priority, w, get(priority, w)+W2); //updates the priority if(get(color, w) == Color::white() ){ put(color, w, Color::green() ); // gives the vertex a preactive status priority_list.push_front(w); // puts the vertex into the priority queue } //end if } //end if } //end for } //end if } //end for } //end while return permutation; }
Player* ScriptedAI::GetPlayerAtMinimumRange(float fMinimumRange) { Player* player = NULL; CellPair pair(Trinity::ComputeCellPair(me->GetPositionX(), me->GetPositionY())); Cell cell(pair); cell.data.Part.reserved = ALL_DISTRICT; cell.SetNoCreate(); Trinity::PlayerAtMinimumRangeAway check(me, fMinimumRange); Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway> searcher(me, player, check); TypeContainerVisitor<Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway>, GridTypeMapContainer> visitor(searcher); cell.Visit(pair, visitor, *(me->GetMap())); return player; }
int main(int argc, char **argv) { #ifdef QT_BOOTSTRAPPED initBinaryDir( #ifndef Q_OS_WIN argv[0] #endif ); #else QCoreApplication app(argc, argv); #ifndef Q_OS_WIN32 QTranslator translator; QTranslator qtTranslator; QString sysLocale = QLocale::system().name(); QString resourceDir = QLibraryInfo::location(QLibraryInfo::TranslationsPath); if (translator.load(QLatin1String("linguist_") + sysLocale, resourceDir) && qtTranslator.load(QLatin1String("qt_") + sysLocale, resourceDir)) { app.installTranslator(&translator); app.installTranslator(&qtTranslator); } #endif // Q_OS_WIN32 #endif // QT_BOOTSTRAPPED ConversionData cd; cd.m_verbose = true; // the default is true starting with Qt 4.2 bool removeIdentical = false; Translator tor; QStringList inputFiles; QString outputFile; for (int i = 1; i < argc; ++i) { if (!strcmp(argv[i], "-compress")) { cd.m_saveMode = SaveStripped; continue; } else if (!strcmp(argv[i], "-idbased")) { cd.m_idBased = true; continue; } else if (!strcmp(argv[i], "-nocompress")) { cd.m_saveMode = SaveEverything; continue; } else if (!strcmp(argv[i], "-removeidentical")) { removeIdentical = true; continue; } else if (!strcmp(argv[i], "-nounfinished")) { cd.m_ignoreUnfinished = true; continue; } else if (!strcmp(argv[i], "-markuntranslated")) { if (i == argc - 1) { printUsage(); return 1; } cd.m_unTrPrefix = QString::fromLocal8Bit(argv[++i]); } else if (!strcmp(argv[i], "-silent")) { cd.m_verbose = false; continue; } else if (!strcmp(argv[i], "-verbose")) { cd.m_verbose = true; continue; } else if (!strcmp(argv[i], "-version")) { printOut(LR::tr("lrelease version %1\n").arg(QLatin1String(QT_VERSION_STR))); return 0; } else if (!strcmp(argv[i], "-qm")) { if (i == argc - 1) { printUsage(); return 1; } outputFile = QString::fromLocal8Bit(argv[++i]); } else if (!strcmp(argv[i], "-help")) { printUsage(); return 0; } else if (argv[i][0] == '-') { printUsage(); return 1; } else { inputFiles << QString::fromLocal8Bit(argv[i]); } } if (inputFiles.isEmpty()) { printUsage(); return 1; } foreach (const QString &inputFile, inputFiles) { if (inputFile.endsWith(QLatin1String(".pro"), Qt::CaseInsensitive) || inputFile.endsWith(QLatin1String(".pri"), Qt::CaseInsensitive)) { QFileInfo fi(inputFile); parseHandler.verbose = evalHandler.verbose = cd.isVerbose(); ProFileOption option; #ifdef QT_BOOTSTRAPPED option.initProperties(binDir + QLatin1String("/qmake")); #else option.initProperties(app.applicationDirPath() + QLatin1String("/qmake")); #endif ProFileParser parser(0, &parseHandler); ProFileEvaluator visitor(&option, &parser, &evalHandler); ProFile *pro; if (!(pro = parser.parsedProFile(QDir::cleanPath(fi.absoluteFilePath())))) { printErr(LR::tr( "lrelease error: cannot read project file '%1'.\n") .arg(inputFile)); continue; } if (!visitor.accept(pro)) { printErr(LR::tr( "lrelease error: cannot process project file '%1'.\n") .arg(inputFile)); pro->deref(); continue; } pro->deref(); QStringList translations = visitor.values(QLatin1String("TRANSLATIONS")); if (translations.isEmpty()) { printErr(LR::tr( "lrelease warning: Met no 'TRANSLATIONS' entry in project file '%1'\n") .arg(inputFile)); } else { QDir proDir(fi.absolutePath()); foreach (const QString &trans, translations) if (!releaseTsFile(QFileInfo(proDir, trans).filePath(), cd, removeIdentical)) return 1; } } else { if (outputFile.isEmpty()) {
// Calculates the size of serialized header in bytes. uint64_t Size() { coding::binary::HeaderSizeOfVisitor visitor; visitor(*this); return visitor.m_size; }
void Deserialize(Source & source) { coding::binary::HeaderDesVisitor<Source> visitor(source); visitor(*this); }
//! Distribute the budget based on the projected size and the primitive count of the child nodes. static void distributeProjectedSizeAndPrimitiveCount(double value, const Util::StringIdentifier & attributeId, Node * node, FrameContext & context) { static const Util::StringIdentifier primitiveCountId("PrimitiveCount"); struct PrimitiveCountAnnotationVisitor : public NodeVisitor { const Util::StringIdentifier & m_primitiveCountId; PrimitiveCountAnnotationVisitor(const Util::StringIdentifier & p_primitiveCountId) : m_primitiveCountId(p_primitiveCountId) { } virtual ~PrimitiveCountAnnotationVisitor() { } NodeVisitor::status leave(Node * _node) override { auto geoNode = dynamic_cast<GeometryNode *>(_node); uint32_t primitiveCount = 0; if(geoNode != nullptr) { const auto mesh = geoNode->getMesh(); primitiveCount = mesh == nullptr ? 0 : mesh->getPrimitiveCount(); } else { const auto children = getChildNodes(_node); for(const auto & child : children) { primitiveCount += child->getAttribute(m_primitiveCountId)->toUnsignedInt(); } } _node->setAttribute(m_primitiveCountId, Util::GenericAttribute::createNumber(primitiveCount)); return CONTINUE_TRAVERSAL; } }; const auto children = getChildNodes(node); // A tuple stores the primitive count, the node and its projected size. std::vector<std::tuple<uint32_t, Node *, float>> primitiveCountNodeProjSizeTuples; primitiveCountNodeProjSizeTuples.reserve(children.size()); double projSizeSum = 0.0; const Geometry::Rect_f screenRect(context.getRenderingContext().getWindowClientArea()); for(const auto & child : children) { if(!child->isAttributeSet(primitiveCountId)) { PrimitiveCountAnnotationVisitor visitor(primitiveCountId); child->traverse(visitor); } const auto primitiveCount = child->getAttribute(primitiveCountId)->toUnsignedInt(); // Clip the projected rect to the screen. auto projRect = context.getProjectedRect(child); projRect.clipBy(screenRect); const auto projSize = projRect.getArea(); projSizeSum += projSize; primitiveCountNodeProjSizeTuples.emplace_back(primitiveCount, child, projSize); } // Begin with the node with the lowest primitive count std::sort(primitiveCountNodeProjSizeTuples.begin(), primitiveCountNodeProjSizeTuples.end()); for(const auto & primitiveCountNodeProjSizeTuple : primitiveCountNodeProjSizeTuples) { const auto primitiveCount = std::get<0>(primitiveCountNodeProjSizeTuple); const auto projSize = std::get<2>(primitiveCountNodeProjSizeTuple); const auto projSizeFactor = projSize / projSizeSum; const auto primitiveAssignment = std::min(static_cast<uint32_t>(projSizeFactor * value), primitiveCount); setOrUpdateAttribute(std::get<1>(primitiveCountNodeProjSizeTuple), attributeId, primitiveAssignment); value -= primitiveAssignment; projSizeSum -= projSize; } }
CSVRender::WorldspaceHitResult CSVRender::WorldspaceWidget::mousePick (const QPoint& localPos, unsigned int interactionMask) const { // (0,0) is considered the lower left corner of an OpenGL window int x = localPos.x(); int y = height() - localPos.y(); // Convert from screen space to world space osg::Matrixd wpvMat; wpvMat.preMult (mView->getCamera()->getViewport()->computeWindowMatrix()); wpvMat.preMult (mView->getCamera()->getProjectionMatrix()); wpvMat.preMult (mView->getCamera()->getViewMatrix()); wpvMat = osg::Matrixd::inverse (wpvMat); osg::Vec3d start = wpvMat.preMult (osg::Vec3d(x, y, 0)); osg::Vec3d end = wpvMat.preMult (osg::Vec3d(x, y, 1)); osg::Vec3d direction = end - start; // Get intersection osg::ref_ptr<osgUtil::LineSegmentIntersector> intersector (new osgUtil::LineSegmentIntersector( osgUtil::Intersector::MODEL, start, end)); intersector->setIntersectionLimit(osgUtil::LineSegmentIntersector::NO_LIMIT); osgUtil::IntersectionVisitor visitor(intersector); visitor.setTraversalMask(interactionMask); mView->getCamera()->accept(visitor); // Get relevant data for (osgUtil::LineSegmentIntersector::Intersections::iterator it = intersector->getIntersections().begin(); it != intersector->getIntersections().end(); ++it) { osgUtil::LineSegmentIntersector::Intersection intersection = *it; // reject back-facing polygons if (direction * intersection.getWorldIntersectNormal() > 0) { continue; } for (std::vector<osg::Node*>::iterator it = intersection.nodePath.begin(); it != intersection.nodePath.end(); ++it) { osg::Node* node = *it; if (osg::ref_ptr<CSVRender::TagBase> tag = dynamic_cast<CSVRender::TagBase *>(node->getUserData())) { WorldspaceHitResult hit = { true, tag, 0, 0, 0, intersection.getWorldIntersectPoint() }; if (intersection.indexList.size() >= 3) { hit.index0 = intersection.indexList[0]; hit.index1 = intersection.indexList[1]; hit.index2 = intersection.indexList[2]; } return hit; } } // Something untagged, probably terrain WorldspaceHitResult hit = { true, 0, 0, 0, 0, intersection.getWorldIntersectPoint() }; if (intersection.indexList.size() >= 3) { hit.index0 = intersection.indexList[0]; hit.index1 = intersection.indexList[1]; hit.index2 = intersection.indexList[2]; } return hit; } // Default placement direction.normalize(); direction *= CSMPrefs::get()["Scene Drops"]["distance"].toInt(); WorldspaceHitResult hit = { false, 0, 0, 0, 0, start + direction }; return hit; }
void collectStackRoots(TraceStack *stack) { unw_cursor_t cursor; unw_context_t uc; unw_word_t ip, sp, bp; // force callee-save registers onto the stack: // Actually, I feel like this is pretty brittle: // collectStackRoots itself is allowed to save the callee-save registers // on its own stack. jmp_buf registers __attribute__((aligned(sizeof(void*)))); #ifndef NVALGRIND if (RUNNING_ON_VALGRIND) { memset(®isters, 0, sizeof(registers)); memset(&cursor, 0, sizeof(cursor)); memset(&uc, 0, sizeof(uc)); memset(&ip, 0, sizeof(ip)); memset(&sp, 0, sizeof(sp)); memset(&bp, 0, sizeof(bp)); } #endif setjmp(registers); assert(sizeof(registers) % 8 == 0); //void* stack_bottom = __builtin_frame_address(0); collectRoots(®isters, ®isters + 1, stack); unw_getcontext(&uc); unw_init_local(&cursor, &uc); TraceStackGCVisitor visitor(stack); int code; while (true) { int code = unw_step(&cursor); // Negative codes are errors, zero means that there isn't a new frame. ASSERT(code >= 0 && "something broke unwinding!", "%d '%s'", code, unw_strerror(code)); assert(code != 0 && "didn't get to the top of the stack!"); unw_get_reg(&cursor, UNW_REG_IP, &ip); unw_get_reg(&cursor, UNW_REG_SP, &sp); unw_get_reg(&cursor, UNW_TDEP_BP, &bp); void* cur_sp = (void*)sp; void* cur_bp = (void*)bp; //std::string name = g.func_addr_registry.getFuncNameAtAddress((void*)ip, true); //if (VERBOSITY()) printf("ip = %lx (%s), stack = [%p, %p)\n", (long) ip, name.c_str(), cur_sp, cur_bp); unw_proc_info_t pip; unw_get_proc_info(&cursor, &pip); if (pip.start_ip == (uintptr_t)&__libc_start_main) { break; } if (pip.start_ip == (intptr_t)interpretFunction) { // TODO Do we still need to crawl the interpreter itself? gatherInterpreterRootsForFrame(&visitor, cur_bp); } collectRoots(cur_sp, (char*)cur_bp, stack); } }
static inline void apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)>& geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2) { return boost::apply_visitor(visitor(), geometry1, geometry2); }
int be_visitor_amh_interface_ss::visit_operation (be_operation *node) { be_visitor_amh_operation_ss visitor (this->ctx_); return visitor.visit_operation (node); }
bool AssemblyLeafVisitor::visit( const vector<UniqueID>& items, const vector<GAABB3>& bboxes, const size_t begin, const size_t end, const ShadingRay::RayType& ray, const ShadingRay::RayInfoType& /*ray_info*/, const double tmin, const double tmax, double& distance) { assert(begin + 1 == end); // Retrieve the assembly instance. const AssemblyInstance* assembly_instance = m_tree.m_scene.assembly_instances().get_by_uid(items[begin]); assert(assembly_instance); ShadingPoint result; result.m_ray.m_tmin = tmin; result.m_ray.m_tmax = tmax; result.m_ray.m_time = m_shading_point.m_ray.m_time; result.m_ray.m_flags = m_shading_point.m_ray.m_flags; // Transform the ray to assembly instance space. transform_ray_to_assembly_instance_space( assembly_instance, m_parent_shading_point, ray, result.m_ray); const RayInfo3d ray_info(result.m_ray); if (assembly_instance->get_assembly().is_flushable()) { // Retrieve the region tree of this assembly. const RegionTree& region_tree = *m_region_tree_cache.access( assembly_instance->get_assembly_uid(), m_tree.m_region_trees); // Check the intersection between the ray and the region tree. RegionLeafVisitor visitor( result, m_triangle_tree_cache #ifdef FOUNDATION_BSP_ENABLE_TRAVERSAL_STATS , m_triangle_bsp_stats #endif ); RegionLeafIntersector intersector; #ifdef FOUNDATION_BSP_ENABLE_TRAVERSAL_STATS bsp::TraversalStatistics stats; intersector.intersect( region_tree, result.m_ray, ray_info, visitor, stats); #else intersector.intersect( region_tree, result.m_ray, ray_info, visitor); #endif } else { // Retrieve the triangle tree of this assembly. const TriangleTree* triangle_tree = m_triangle_tree_cache.access( assembly_instance->get_assembly_uid(), m_tree.m_triangle_trees); if (triangle_tree) { // Check the intersection between the ray and the triangle tree. TriangleLeafVisitor visitor(result); TriangleLeafIntersector intersector; intersector.intersect( *triangle_tree, result.m_ray, ray_info, visitor #ifdef FOUNDATION_BSP_ENABLE_TRAVERSAL_STATS , m_triangle_bsp_stats #endif ); visitor.read_hit_triangle_data(); } } // Keep track of the closest hit. if (result.m_hit && result.m_ray.m_tmax < m_shading_point.m_ray.m_tmax) { m_shading_point.m_ray.m_tmax = result.m_ray.m_tmax; m_shading_point.m_hit = true; m_shading_point.m_bary = result.m_bary; m_shading_point.m_asm_instance_uid = assembly_instance->get_uid(); m_shading_point.m_object_instance_index = result.m_object_instance_index; m_shading_point.m_region_index = result.m_region_index; m_shading_point.m_triangle_index = result.m_triangle_index; m_shading_point.m_triangle_support_plane = result.m_triangle_support_plane; } // Continue traversal. distance = m_shading_point.m_ray.m_tmax; return true; }
int be_visitor_amh_interface_ss::visit_attribute (be_attribute *node) { be_visitor_amh_operation_ss visitor (this->ctx_); return visitor.visit_attribute (node); }
bool LocationService::HandleAdminRegion(const LocationSearch& search, const LocationSearch::Entry& searchEntry, const AdminRegionMatchVisitor::AdminRegionResult& adminRegionResult, LocationSearchResult& result) const { if (searchEntry.locationPattern.empty()) { LocationSearchResult::Entry entry; entry.adminRegion=adminRegionResult.adminRegion; if (adminRegionResult.isMatch) { entry.adminRegionMatchQuality=LocationSearchResult::match; } else { entry.adminRegionMatchQuality=LocationSearchResult::candidate; } entry.locationMatchQuality=LocationSearchResult::none; entry.poiMatchQuality=LocationSearchResult::none; entry.addressMatchQuality=LocationSearchResult::none; result.results.push_back(entry); return true; } //std::cout << " Search for location '" << searchEntry.locationPattern << "'" << " in " << adminRegionResult.adminRegion->name << "/" << adminRegionResult.adminRegion->aliasName << std::endl; LocationMatchVisitor visitor(adminRegionResult.adminRegion, searchEntry.locationPattern, search.limit>=result.results.size() ? search.limit-result.results.size() : 0); if (!VisitAdminRegionLocations(*adminRegionResult.adminRegion, visitor)) { log.Error() << "Error during traversal of region location list"; return false; } if (visitor.poiResults.empty() && visitor.locationResults.empty()) { // If we search for a location within an area, // we do not return the found area as hit, if we // did not find the location in it. return true; } for (const auto& poiResult : visitor.poiResults) { if (!HandleAdminRegionPOI(search, adminRegionResult, poiResult, result)) { log.Error() << "Error during traversal of region poi list"; return false; } } for (const auto& locationResult : visitor.locationResults) { //std::cout << " - '" << locationResult->location->name << "'" << std::endl; if (!HandleAdminRegionLocation(search, searchEntry, adminRegionResult, locationResult, result)) { log.Error() << "Error during traversal of region location list"; return false; } } return true; }
bool somMayGoBackwards(NFAVertex u, const NGHolder &g, const ue2::unordered_map<NFAVertex, u32> ®ion_map, smgb_cache &cache) { /* Need to ensure all matches of the graph g up to u contain no infixes * which are also matches of the graph to u. * * This is basically the same as firstMatchIsFirst except we g is not * always a dag. As we haven't gotten around to writing an execute_graph * that operates on general graphs, we take some (hopefully) conservative * short cuts. * * Note: if the u can be jumped we will take jump edges * into account as a possibility of som going backwards * * TODO: write a generalised ng_execute_graph/make this less hacky */ assert(&g == &cache.g); if (contains(cache.smgb, u)) { return cache.smgb[u]; } DEBUG_PRINTF("checking if som can go backwards on %u\n", g[u].index); set<NFAEdge> be; BackEdges<set<NFAEdge>> backEdgeVisitor(be); depth_first_search( g.g, visitor(backEdgeVisitor) .root_vertex(g.start) .vertex_index_map(get(&NFAGraphVertexProps::index, g.g))); bool rv; if (0) { exit: DEBUG_PRINTF("using cached result\n"); cache.smgb[u] = rv; return rv; } assert(contains(region_map, u)); const u32 u_region = region_map.at(u); for (const auto &e : be) { NFAVertex s = source(e, g); NFAVertex t = target(e, g); /* only need to worry about big cycles including/before u */ DEBUG_PRINTF("back edge %u %u\n", g[s].index, g[t].index); if (s != t && region_map.at(s) <= u_region) { DEBUG_PRINTF("eek big cycle\n"); rv = true; /* big cycle -> eek */ goto exit; } } ue2::unordered_map<NFAVertex, NFAVertex> orig_to_copy; NGHolder c_g; cloneHolder(c_g, g, &orig_to_copy); for (NFAVertex v : vertices_range(g)) { if (!is_virtual_start(v, g)) { continue; } NFAVertex c_v = orig_to_copy[v]; orig_to_copy[v] = c_g.startDs; for (NFAVertex c_w : adjacent_vertices_range(c_v, c_g)) { add_edge_if_not_present(c_g.startDs, c_w, c_g); } clear_vertex(c_v, c_g); } NFAVertex c_u = orig_to_copy[u]; clear_in_edges(c_g.acceptEod, c_g); add_edge(c_g.accept, c_g.acceptEod, c_g); clear_in_edges(c_g.accept, c_g); clear_out_edges(c_u, c_g); if (hasSelfLoop(u, g)) { add_edge(c_u, c_u, c_g); } add_edge(c_u, c_g.accept, c_g); set<NFAVertex> u_succ; insert(&u_succ, adjacent_vertices(u, g)); u_succ.erase(u); for (auto t : inv_adjacent_vertices_range(u, g)) { if (t == u) { continue; } for (auto v : adjacent_vertices_range(t, g)) { if (contains(u_succ, v)) { add_edge(orig_to_copy[t], c_g.accept, c_g); break; } } } pruneUseless(c_g); be.clear(); depth_first_search(c_g.g, visitor(backEdgeVisitor).root_vertex(c_g.start). vertex_index_map(get(&NFAGraphVertexProps::index, c_g.g))); for (const auto &e : be) { NFAVertex s = source(e, c_g); NFAVertex t = target(e, c_g); DEBUG_PRINTF("back edge %u %u\n", c_g[s].index, c_g[t].index); if (s != t) { assert(0); DEBUG_PRINTF("eek big cycle\n"); rv = true; /* big cycle -> eek */ goto exit; } } DEBUG_PRINTF("checking acyclic+selfloop graph\n"); rv = !firstMatchIsFirst(c_g); DEBUG_PRINTF("som may regress? %d\n", (int)rv); goto exit; }
Player* ScriptedAI::GetPlayerAtMinimumRange(float fMinimumRange) { Player* pPlayer = NULL; CellPair pair(CW::ComputeCellPair(m_creature->GetPositionX(), m_creature->GetPositionY())); Cell cell(pair); cell.data.Part.reserved = ALL_DISTRICT; cell.SetNoCreate(); CW::PlayerAtMinimumRangeAway check(m_creature, fMinimumRange); CW::PlayerSearcher<CW::PlayerAtMinimumRangeAway> searcher(m_creature, pPlayer, check); TypeContainerVisitor<CW::PlayerSearcher<CW::PlayerAtMinimumRangeAway>, GridTypeMapContainer> visitor(searcher); CellLock<GridReadGuard> cell_lock(cell, pair); cell_lock->Visit(cell_lock, visitor, *(m_creature->GetMap())); return pPlayer; }
static void test_grid() { /* An empty grid behaves the same as a control so test here. */ test_control<gui2::tgrid>(); //std::cerr << __func__ << ": Detailed test.\n"; /* Test the child part here. */ gui2::tgrid grid(2 ,2); add_widget(grid, new gui2::tlabel(), "(1,1)", 0, 0); add_widget(grid, new gui2::tlabel(), "(1,2)", 0, 1); add_widget(grid, new gui2::tlabel(), "(2,1)", 1, 0); add_widget(grid, new gui2::tlabel(), "(2,2)", 1, 1); boost::scoped_ptr<gui2::iterator::twalker_> visitor(grid.create_walker()); /***** LABEL 1,1 *****/ BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(NULL)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(1,1)"); /***** LABEL 2,1 *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::valid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(NULL)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(2,1)"); /***** LABEL 1,2 *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::valid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(NULL)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(1,2)"); /***** LABEL 2,2 *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::valid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(NULL)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(2,2)"); /***** END *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::invalid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), true); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(NULL)); /***** POST END *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::fail); }
Player* ScriptedAI::GetPlayerAtMinimumRange(float minimumRange) { Player* player = NULL; CellCoord pair(Trinity::ComputeCellCoord(me->GetPositionX(), me->GetPositionY())); Cell cell(pair); cell.SetNoCreate(); Trinity::PlayerAtMinimumRangeAway check(me, minimumRange); Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway> searcher(me, player, check); TypeContainerVisitor<Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway>, GridTypeMapContainer> visitor(searcher); cell.Visit(pair, visitor, *me->GetMap(), *me, minimumRange); return player; }
void Serialize(Sink & sink) { coding::binary::HeaderSerVisitor<Sink> visitor(sink); visitor(*this); }
void GetCreatureListWithEntryInGrid(std::list<Creature*>& lList, WorldObject* pSource, uint32 uiEntry, float fMaxSearchRange) { CellPair pair(MaNGOS::ComputeCellPair(pSource->GetPositionX(), pSource->GetPositionY())); Cell cell(pair); cell.data.Part.reserved = ALL_DISTRICT; cell.SetNoCreate(); AllCreaturesOfEntryInRange check(pSource, uiEntry, fMaxSearchRange); MaNGOS::CreatureListSearcher<AllCreaturesOfEntryInRange> searcher(lList, check); TypeContainerVisitor<MaNGOS::CreatureListSearcher<AllCreaturesOfEntryInRange>, GridTypeMapContainer> visitor(searcher); CellLock<GridReadGuard> cell_lock(cell, pair); cell_lock->Visit(cell_lock, visitor, *(pSource->GetMap()), *pSource, fMaxSearchRange); }
void markPhase() { #ifndef NVALGRIND // Have valgrind close its eyes while we do the conservative stack and data scanning, // since we'll be looking at potentially-uninitialized values: VALGRIND_DISABLE_ERROR_REPORTING; #endif TraceStack stack(roots); GCVisitor visitor(&stack); threading::visitAllStacks(&visitor); gatherInterpreterRoots(&visitor); for (void* p : nonheap_roots) { Box* b = reinterpret_cast<Box*>(p); BoxedClass* cls = b->cls; if (cls) { ASSERT(cls->gc_visit, "%s", getTypeName(b)); cls->gc_visit(&visitor, b); } } for (auto h : *getRootHandles()) { visitor.visit(h->value); } // if (VERBOSITY()) printf("Found %d roots\n", stack.size()); while (void* p = stack.pop()) { assert(((intptr_t)p) % 8 == 0); GCAllocation* al = GCAllocation::fromUserData(p); assert(isMarked(al)); // printf("Marking + scanning %p\n", p); GCKind kind_id = al->kind_id; if (kind_id == GCKind::UNTRACKED) { continue; } else if (kind_id == GCKind::CONSERVATIVE) { uint32_t bytes = al->kind_data; if (DEBUG >= 2) { if (global_heap.small_arena.contains(p)) { SmallArena::Block* b = SmallArena::Block::forPointer(p); assert(b->size >= bytes + sizeof(GCAllocation)); } } visitor.visitPotentialRange((void**)p, (void**)((char*)p + bytes)); } else if (kind_id == GCKind::PRECISE) { uint32_t bytes = al->kind_data; if (DEBUG >= 2) { if (global_heap.small_arena.contains(p)) { SmallArena::Block* b = SmallArena::Block::forPointer(p); assert(b->size >= bytes + sizeof(GCAllocation)); } } visitor.visitRange((void**)p, (void**)((char*)p + bytes)); } else if (kind_id == GCKind::PYTHON) { Box* b = reinterpret_cast<Box*>(p); BoxedClass* cls = b->cls; if (cls) { // The cls can be NULL since we use 'new' to construct them. // An arbitrary amount of stuff can happen between the 'new' and // the call to the constructor (ie the args get evaluated), which // can trigger a collection. ASSERT(cls->gc_visit, "%s", getTypeName(b)); cls->gc_visit(&visitor, b); } } else if (kind_id == GCKind::HIDDEN_CLASS) { HiddenClass* hcls = reinterpret_cast<HiddenClass*>(p); hcls->gc_visit(&visitor); } else { RELEASE_ASSERT(0, "Unhandled kind: %d", (int)kind_id); } } #ifndef NVALGRIND VALGRIND_ENABLE_ERROR_REPORTING; #endif }