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

        /// Query the current value of the accumulator.        ///        /// /note This function is fully synchronous.        double query_sync()        {            HPX_ASSERT(this->get_id());            return query_async().get();        }

 void save(bool b) {     HPX_ASSERT(0 == static_cast<int>(b) || 1 == static_cast<int>(b));     save_binary(&b, sizeof(bool)); }

 bool empty() const {     HPX_ASSERT(messages_.size() == handlers_.size());     return messages_.empty(); }

 tss_storage* get_or_create_thread_tss_data() {     HPX_ASSERT(m_pimpl);     return m_pimpl->get_thread_tss_data(true); }

 Impl & get() {     HPX_ASSERT(Impl::get_type() == get_type());     return static_cast<impl<Impl>*>(this)->impl_; }

 thread_id_repr_type get_thread_id() const {   HPX_ASSERT(m_pimpl);   return m_pimpl->get_thread_id(); }

 std::size_t set_thread_data(std::size_t data) {     HPX_ASSERT(m_pimpl);     return m_pimpl->set_thread_data(data); }

 jacobi::row stencil_iterator::get(std::size_t idx) {     HPX_ASSERT(rows[idx].id);     return rows[idx]; }

 double operator[](std::size_t i) const {     HPX_ASSERT(data_);     return data_[i]; }

 ~memory_block_header() {     // invoke destructor, if needed     HPX_ASSERT(this->managing_object_.destruct());     this->managing_object_.destruct()(this->get_ptr()); }

 void set_parcelhandler(parcelhandler* ph) {     HPX_ASSERT(ph_ == 0);     ph_ = ph; }

 ~prepare_main_thread() noexcept {     BOOL result = ConvertFiberToThread();     HPX_ASSERT(FALSE != result);     HPX_UNUSED(result); }

 prepare_main_thread() noexcept {     LPVOID result = ConvertThreadToFiber(nullptr);     HPX_ASSERT(nullptr != result);     HPX_UNUSED(result); }

 HPX_FORCEINLINE VOID CALLBACK trampoline(LPVOID pv) {     T* fun = static_cast<T*>(pv);     HPX_ASSERT(fun);     (*fun)(); }

 hpx::state thread_pool<Scheduler>::get_state(std::size_t num_thread) const {     HPX_ASSERT(num_thread != std::size_t(-1));     return sched_.get_state(num_thread).load(); }

 bool pending() const {   HPX_ASSERT(m_pimpl);   return m_pimpl->pending(); }

        bool test(std::size_t position) const        {            HPX_ASSERT(position < security::traits::capability<>::size);            return (bits_[position / CHAR_BIT] & (1ull << (position % CHAR_BIT))) != 0;        }

 std::size_t get_thread_data() const {     HPX_ASSERT(m_pimpl);     return m_pimpl->get_thread_data(); }

    // schedule threads based on given parcel    void applier::schedule_action(parcelset::parcel p, std::size_t num_thread)    {        // fetch the set of destinations#if !defined(HPX_SUPPORT_MULTIPLE_PARCEL_DESTINATIONS)        std::size_t const size = 1ul;#else        std::size_t const size = p.size();#endif        naming::id_type const* ids = p.destinations();        naming::address const* addrs = p.addrs();        // decode the action-type in the parcel        std::unique_ptr<actions::continuation> cont = p.get_continuation();        actions::base_action * act = p.get_action();#if defined(HPX_HAVE_SECURITY)        // we look up the certificate of the originating locality, no matter        // whether this parcel was routed through another locality or not        boost::uint32_t locality_id =            naming::get_locality_id_from_gid(p.get_parcel_id());        error_code ec(lightweight);        components::security::signed_certificate const& cert =            get_locality_certificate(locality_id, ec);        if (verify_capabilities_ && ec) {            // we should have received the sender's certificate by now            HPX_THROW_EXCEPTION(security_error,                "applier::schedule_action",                boost::str(boost::format("couldn't extract sender's "                    "certificate (sender locality id: %1%)") % locality_id));            return;        }        components::security::capability caps_sender;        if (verify_capabilities_)            caps_sender = cert.get_type().get_capability();#endif        int comptype = act->get_component_type();        naming::gid_type dest = p.destination_locality();        // if the parcel carries a continuation it should be directed to a        // single destination        HPX_ASSERT(!cont || size == 1);        naming::resolver_client& client = hpx::naming::get_agas_client();        // schedule a thread for each of the destinations        for (std::size_t i = 0; i != size; ++i)        {            naming::address const& addr = addrs[i];            // make sure this parcel destination matches the proper locality            HPX_ASSERT(dest == addr.locality_);            // decode the local virtual address of the parcel            naming::address::address_type lva = addr.address_;            // by convention, a zero address references either the local            // runtime support component or one of the AGAS components            if (0 == lva)            {                switch(comptype)                {                case components::component_runtime_support:                    lva = get_runtime_support_raw_gid().get_lsb();                    break;                case components::component_agas_primary_namespace:                    lva = get_agas_client().get_primary_ns_lva();                    break;                case components::component_agas_symbol_namespace:                    lva = get_agas_client().get_symbol_ns_lva();                    break;                case components::component_plain_function:                    break;                default:                    HPX_ASSERT(false);                }            }            else if (comptype == components::component_memory)            {                HPX_ASSERT(naming::refers_to_virtual_memory(ids[i].get_gid()));                lva = get_memory_raw_gid().get_lsb();            }            // make sure the target has not been migrated away            auto r = act->was_object_migrated(ids[i], lva);            if (r.first)            {#if defined(HPX_SUPPORT_MULTIPLE_PARCEL_DESTINATIONS)                // it's unclear at this point what could be done if there is                // more than one destination                HPX_ASSERT(size == 1);#endif                // set continuation in outgoing parcel                if (cont)//.........这里部分代码省略.........

 tss_storage* get_thread_tss_data() {     HPX_ASSERT(m_pimpl);     return m_pimpl->get_thread_tss_data(false); }

 applier& get_applier() {     // should have been initialized     HPX_ASSERT(NULL != applier::applier_.get());     return **applier::applier_; }

 static void set(components::component_type) {     HPX_ASSERT(false); }

 /// Requires: No threads are blocked at the synchronization point. /// /// /note May be called even if some threads have not yet returned ///       from wait() or count_down_and_wait(), provided that counter_ ///       is 0. /// /note The destructor might not return until all threads have exited ///       wait() or count_down_and_wait(). /// /note It is the caller's responsibility to ensure that no other ///       thread enters wait() after one thread has called the ///       destructor. This may require additional coordination. ~latch () {     boost::unique_lock<mutex_type> l(mtx_);     HPX_ASSERT(counter_ == 0); }

 std::size_t size() const {     HPX_ASSERT(messages_.size() == handlers_.size());     return messages_.size(); }

 void load(bool & b) {     load_binary(&b, sizeof(bool));     HPX_ASSERT(0 == static_cast<int>(b) || 1 == static_cast<int>(b)); }

 /// Erase all values with the given key from the partition_unordered_map /// container. /// /// /param key  Key of the element in the partition_unordered_map /// /// /return This returns the hpx::future containing the number of ///         elements erased /// future<std::size_t> erase(Key const& key) {     HPX_ASSERT(this->get_gid());     return hpx::async<typename server_type::erase_action>(         this->get_gid(), key); }