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
}
