自学教程：C++ BOOST_ASSERT函数代码示例

/** * Creates the nodes in the edge expanded graph from edges in the node-based graph. */void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(){    SimpleLogger().Write() << "Identifying components of the (compressed) road network";    // Run a BFS on the undirected graph and identify small components    TarjanSCC<NodeBasedDynamicGraph> component_explorer(m_node_based_graph, *m_restriction_map,                                                        m_barrier_nodes);    component_explorer.run();    SimpleLogger().Write() << "identified: "                           << component_explorer.get_number_of_components() - removed_node_count                           << " (compressed) components";    SimpleLogger().Write() << "identified "                           << component_explorer.get_size_one_count() - removed_node_count                           << " (compressed) SCCs of size 1";    SimpleLogger().Write() << "generating edge-expanded nodes";    Percent progress(m_node_based_graph->GetNumberOfNodes());    // loop over all edges and generate new set of nodes    for (const auto node_u : osrm::irange(0u, m_node_based_graph->GetNumberOfNodes()))    {        BOOST_ASSERT(node_u != SPECIAL_NODEID);        BOOST_ASSERT(node_u < m_node_based_graph->GetNumberOfNodes());        progress.printStatus(node_u);        for (EdgeID e1 : m_node_based_graph->GetAdjacentEdgeRange(node_u))        {            const EdgeData &edge_data = m_node_based_graph->GetEdgeData(e1);            BOOST_ASSERT(e1 != SPECIAL_EDGEID);            const NodeID node_v = m_node_based_graph->GetTarget(e1);            BOOST_ASSERT(SPECIAL_NODEID != node_v);            // pick only every other edge, since we have every edge as an outgoing            // and incoming egde            if (node_u > node_v)            {                continue;            }            BOOST_ASSERT(node_u < node_v);            // Note: edges that end on barrier nodes or on a turn restriction            // may actually be in two distinct components. We choose the smallest            const unsigned size_of_component =                std::min(component_explorer.get_component_size(node_u),                         component_explorer.get_component_size(node_v));            const unsigned id_of_smaller_component = [node_u, node_v, &component_explorer]            {                if (component_explorer.get_component_size(node_u) <                    component_explorer.get_component_size(node_v))                {                    return component_explorer.get_component_id(node_u);                }                return component_explorer.get_component_id(node_v);            }();            const bool component_is_tiny = size_of_component < 1000;            // we only set edgeBasedNodeID for forward edges            if (edge_data.edgeBasedNodeID == SPECIAL_NODEID)            {                InsertEdgeBasedNode(node_v, node_u,                                    (component_is_tiny ? id_of_smaller_component + 1 : 0));            }            else            {                InsertEdgeBasedNode(node_u, node_v,                                    (component_is_tiny ? id_of_smaller_component + 1 : 0));            }        }    }    SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size()                           << " nodes in edge-expanded graph";}

 static int ispunct(int ch) {     BOOST_ASSERT(isascii_(ch));     return (ascii_char_types[ch] & BOOST_CC_PUNCT); }

 static int isupper(int ch) {     BOOST_ASSERT(isascii_(ch));     return (ascii_char_types[ch] & BOOST_CC_UPPER); }

 static int isalpha(int ch) {     BOOST_ASSERT(isascii_(ch));     return (ascii_char_types[ch] & BOOST_CC_ALPHA); }

 static int iscntrl(int ch) {     BOOST_ASSERT(isascii_(ch));     return (ascii_char_types[ch] & BOOST_CC_CTRL); }

 void recompute(std::vector<hpx::naming::id_type> const& search_objects) {     BOOST_ASSERT(gid_);     this->base_type::recompute(gid_, search_objects); }

WaterUseEquipmentDefinitionInspectorView::WaterUseEquipmentDefinitionInspectorView(bool isIP, const openstudio::model::Model& model, QWidget * parent)    : ModelObjectInspectorView(model, true, parent){    m_isIP = isIP;    bool isConnected = false;    QWidget* visibleWidget = new QWidget();    this->stackedWidget()->addWidget(visibleWidget);    QGridLayout* mainGridLayout = new QGridLayout();    mainGridLayout->setContentsMargins(7,7,7,7);    mainGridLayout->setSpacing(14);    visibleWidget->setLayout(mainGridLayout);    // Name    QLabel* label = new QLabel("Name: ");    label->setObjectName("H2");    mainGridLayout->addWidget(label,0,0);    m_nameEdit = new OSLineEdit();    mainGridLayout->addWidget(m_nameEdit,1,0,1,3);    // End Use Subcategory    label = new QLabel("End Use Subcategory: ");    label->setObjectName("H2");    mainGridLayout->addWidget(label,2,0);    m_endUseSubcategoryEdit = new OSLineEdit();    mainGridLayout->addWidget(m_endUseSubcategoryEdit,3,0,1,3);    // Peak Flow Rate    label = new QLabel("Peak Flow Rate: ");    label->setObjectName("H2");    mainGridLayout->addWidget(label,4,0);    m_peakFlowRateEdit = new OSQuantityEdit(m_isIP);    isConnected = connect(this, SIGNAL(toggleUnitsClicked(bool)), m_peakFlowRateEdit, SLOT(onUnitSystemChange(bool)));    BOOST_ASSERT(isConnected);    mainGridLayout->addWidget(m_peakFlowRateEdit,5,0,1,3);    // Target Temperature Schedule    label = new QLabel("Target Temperature Schedule: ");    label->setObjectName("H2");    mainGridLayout->addWidget(label,6,0);    m_targetTemperatureScheduleVC = new TargetTemperatureScheduleVC();    m_targetTemperatureScheduleDZ = new OSDropZone(m_targetTemperatureScheduleVC);    m_targetTemperatureScheduleDZ->setMaxItems(1);    mainGridLayout->addWidget(m_targetTemperatureScheduleDZ,7,0,1,3);    // Sensible Fraction Schedule    label = new QLabel("Sensible Fraction Schedule: ");    label->setObjectName("H2");    mainGridLayout->addWidget(label,8,0);    m_sensibleFractionScheduleVC = new SensibleFractionScheduleVC();    m_sensibleFractionScheduleDZ = new OSDropZone(m_sensibleFractionScheduleVC);    m_sensibleFractionScheduleDZ->setMaxItems(1);    mainGridLayout->addWidget(m_sensibleFractionScheduleDZ,9,0,1,3);    // Latent Fraction Schedule    label = new QLabel("Latent Fraction Schedule: ");    label->setObjectName("H2");    mainGridLayout->addWidget(label,10,0);    m_latentFractionScheduleVC = new LatentFractionScheduleVC();    m_latentFractionScheduleDZ = new OSDropZone(m_latentFractionScheduleVC);    m_latentFractionScheduleDZ->setMaxItems(1);    mainGridLayout->addWidget(m_latentFractionScheduleDZ,11,0,1,3);    // Stretch    mainGridLayout->setRowStretch(12,100);    mainGridLayout->setColumnStretch(3,100);}

 lcos::future<void> enforce_async(std::vector<hpx::naming::id_type> const& master_gids,double dt,                                        std::size_t n,std::size_t N) {     BOOST_ASSERT(gid_);     return this->base_type::enforce_async(gid_,master_gids,dt,n,N); }

 void move(double dt,double time) {     BOOST_ASSERT(gid_);     this->base_type::move(gid_,dt,time); }

 lcos::future<void> move_async(double dt,double time) {     BOOST_ASSERT(gid_);     return this->base_type::move_async(gid_,dt,time); }

 lcos::future<void> adjust_async(double dt) {     BOOST_ASSERT(gid_);     return this->base_type::adjust_async(gid_,dt); }

 polygon_type get_poly() const {     BOOST_ASSERT(gid_);     return this->base_type::get_poly(gid_); }

void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,                                                const NodeID node_v,                                                const unsigned component_id){    // merge edges together into one EdgeBasedNode    BOOST_ASSERT(node_u != SPECIAL_NODEID);    BOOST_ASSERT(node_v != SPECIAL_NODEID);    // find forward edge id and    const EdgeID edge_id_1 = m_node_based_graph->FindEdge(node_u, node_v);    BOOST_ASSERT(edge_id_1 != SPECIAL_EDGEID);    const EdgeData &forward_data = m_node_based_graph->GetEdgeData(edge_id_1);    // find reverse edge id and    const EdgeID edge_id_2 = m_node_based_graph->FindEdge(node_v, node_u);    BOOST_ASSERT(edge_id_2 != SPECIAL_EDGEID);    const EdgeData &reverse_data = m_node_based_graph->GetEdgeData(edge_id_2);    if (forward_data.edgeBasedNodeID == SPECIAL_NODEID &&        reverse_data.edgeBasedNodeID == SPECIAL_NODEID)    {        return;    }    BOOST_ASSERT(m_geometry_compressor.HasEntryForID(edge_id_1) ==                 m_geometry_compressor.HasEntryForID(edge_id_2));    if (m_geometry_compressor.HasEntryForID(edge_id_1))    {        BOOST_ASSERT(m_geometry_compressor.HasEntryForID(edge_id_2));        // reconstruct geometry and put in each individual edge with its offset        const std::vector<GeometryCompressor::CompressedNode> &forward_geometry =            m_geometry_compressor.GetBucketReference(edge_id_1);        const std::vector<GeometryCompressor::CompressedNode> &reverse_geometry =            m_geometry_compressor.GetBucketReference(edge_id_2);        BOOST_ASSERT(forward_geometry.size() == reverse_geometry.size());        BOOST_ASSERT(0 != forward_geometry.size());        const unsigned geometry_size = static_cast<unsigned>(forward_geometry.size());        BOOST_ASSERT(geometry_size > 1);        // reconstruct bidirectional edge with individual weights and put each into the NN index        std::vector<int> forward_dist_prefix_sum(forward_geometry.size(), 0);        std::vector<int> reverse_dist_prefix_sum(reverse_geometry.size(), 0);        // quick'n'dirty prefix sum as std::partial_sum needs addtional casts        // TODO: move to lambda function with C++11        int temp_sum = 0;        for (const auto i : osrm::irange(0u, geometry_size))        {            forward_dist_prefix_sum[i] = temp_sum;            temp_sum += forward_geometry[i].second;            BOOST_ASSERT(forward_data.distance >= temp_sum);        }        temp_sum = 0;        for (const auto i : osrm::irange(0u, geometry_size))        {            temp_sum += reverse_geometry[reverse_geometry.size() - 1 - i].second;            reverse_dist_prefix_sum[i] = reverse_data.distance - temp_sum;            // BOOST_ASSERT(reverse_data.distance >= temp_sum);        }        NodeID current_edge_source_coordinate_id = node_u;        if (SPECIAL_NODEID != forward_data.edgeBasedNodeID)        {            max_id = std::max(forward_data.edgeBasedNodeID, max_id);        }        if (SPECIAL_NODEID != reverse_data.edgeBasedNodeID)        {            max_id = std::max(reverse_data.edgeBasedNodeID, max_id);        }        // traverse arrays from start and end respectively        for (const auto i : osrm::irange(0u, geometry_size))        {            BOOST_ASSERT(current_edge_source_coordinate_id ==                         reverse_geometry[geometry_size - 1 - i].first);            const NodeID current_edge_target_coordinate_id = forward_geometry[i].first;            BOOST_ASSERT(current_edge_target_coordinate_id != current_edge_source_coordinate_id);            // build edges            m_edge_based_node_list.emplace_back(                forward_data.edgeBasedNodeID, reverse_data.edgeBasedNodeID,                current_edge_source_coordinate_id, current_edge_target_coordinate_id,                forward_data.nameID, forward_geometry[i].second,                reverse_geometry[geometry_size - 1 - i].second, forward_dist_prefix_sum[i],                reverse_dist_prefix_sum[i], m_geometry_compressor.GetPositionForID(edge_id_1),                component_id, i, forward_data.travel_mode, reverse_data.travel_mode);            current_edge_source_coordinate_id = current_edge_target_coordinate_id;            BOOST_ASSERT(m_edge_based_node_list.back().IsCompressed());            BOOST_ASSERT(node_u != m_edge_based_node_list.back().u ||                         node_v != m_edge_based_node_list.back().v);//.........这里部分代码省略.........

 lcos::future<void> recompute_async(std::vector<hpx::naming::id_type> const& search_objects) {     BOOST_ASSERT(gid_);     return this->base_type::recompute_async(gid_, search_objects); }

 void adjust(double dt) {     BOOST_ASSERT(gid_);     this->base_type::adjust(gid_,dt); }

 int search(std::vector<hpx::naming::id_type> const& search_objects) {     BOOST_ASSERT(gid_);     return this->base_type::search(gid_, search_objects); }

 void enforce(std::vector<hpx::naming::id_type> const& master_gids,double dt,              std::size_t n,std::size_t N) {     BOOST_ASSERT(gid_);     this->base_type::enforce(gid_,master_gids,dt,n,N); }

 lcos::future<polygon_type> get_poly_async() const {     BOOST_ASSERT(gid_);     return this->base_type::get_poly_async(gid_); }

 lcos::future<double> get_Y_async()  const {     BOOST_ASSERT(gid_);     return this->base_type::get_Y_async(gid_); }

network_boost::shared_ptr<Object const> object_cache<Key, Object>::do_get(const Key& k, size_type l_max_cache_size){    typedef typename object_cache<Key, Object>::data object_data;    typedef typename map_type::size_type map_size_type;    static object_data s_data;    //    // see if the object is already in the cache:    //    map_iterator mpos = s_data.index.find(k);    if(mpos != s_data.index.end())    {        //        // Eureka!        // We have a cached item, bump it up the list and return it:        //        if(--(s_data.cont.end()) != mpos->second)        {            // splice out the item we want to move:            list_type temp;            temp.splice(temp.end(), s_data.cont, mpos->second);            // and now place it at the end of the list:            s_data.cont.splice(s_data.cont.end(), temp, temp.begin());            BOOST_ASSERT(*(s_data.cont.back().second) == k);            // update index with new position:            mpos->second = --(s_data.cont.end());            BOOST_ASSERT(&(mpos->first) == mpos->second->second);            BOOST_ASSERT(&(mpos->first) == s_data.cont.back().second);        }        return s_data.cont.back().first;    }    //    // if we get here then the item is not in the cache,    // so create it:    //    network_boost::shared_ptr<Object const> result(new Object(k));    //    // Add it to the list, and index it:    //    s_data.cont.push_back(value_type(result, static_cast<Key const*>(0)));    s_data.index.insert(std::make_pair(k, --(s_data.cont.end())));    s_data.cont.back().second = &(s_data.index.find(k)->first);    map_size_type s = s_data.index.size();    BOOST_ASSERT(s_data.index[k]->first.get() == result.get());    BOOST_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);    BOOST_ASSERT(s_data.index.find(k)->first == k);    if(s > l_max_cache_size)    {        //        // We have too many items in the list, so we need to start        // popping them off the back of the list, but only if they're        // being held uniquely by us:        //        list_iterator pos = s_data.cont.begin();        list_iterator last = s_data.cont.end();        while((pos != last) && (s > l_max_cache_size))        {            if(pos->first.unique())            {                list_iterator condemmed(pos);                ++pos;                // now remove the items from our containers,                // then order has to be as follows:                BOOST_ASSERT(s_data.index.find(*(condemmed->second)) != s_data.index.end());                s_data.index.erase(*(condemmed->second));                s_data.cont.erase(condemmed);                --s;            }            else                ++pos;        }        BOOST_ASSERT(s_data.index[k]->first.get() == result.get());        BOOST_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);        BOOST_ASSERT(s_data.index.find(k)->first == k);    }    return result;}

 double get_Y() const {     BOOST_ASSERT(gid_);     return this->base_type::get_Y(gid_); }

 static int isxdigit(int ch) {     BOOST_ASSERT(isascii_(ch));     return (ascii_char_types[ch] & BOOST_CC_XDIGIT); }

 lcos::future<void> set_Y_async(double y) {     BOOST_ASSERT(gid_);     return this->base_type::set_Y_async(gid_, y); }

 static int islower(int ch) {     BOOST_ASSERT(isascii_(ch));     return (ascii_char_types[ch] & BOOST_CC_LOWER); }

 void set_X(double x) {     BOOST_ASSERT(gid_);     this->base_type::set_X(gid_, x); }

 static int isspace(int ch) {     BOOST_ASSERT(isascii_(ch));     return (ascii_char_types[ch] & BOOST_CC_SPACE); }

 void set_Y(double y) {     BOOST_ASSERT(gid_);     this->base_type::set_Y(gid_, y); }

 static int toupper(int ch) {     BOOST_ASSERT(isascii_(ch));     return islower(ch) ? (ch - 'a' + 'A') : ch; }