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

    NetworkAddress::NetworkAddress (string const &server) {        auto off = server.find(':');        if (off == server.npos || off + 1 >= server.size()) {            h = server;            p = -1;        }        else {            h = server.substr(0, off);            p = boost::lexical_cast<int>(server.substr(off+1));        }        // translate hostname to IP address        struct in_addr in;        int r = inet_aton(h.c_str(), &in);        if (r == 0) {            // invalid IP address, use getent to convert to IP address            string cmd(format("getent ahostsv4 %s", h));            FILE *fp = popen(cmd.c_str(), "r");            BOOST_VERIFY(fp);            char line[4000];            while (fgets(line, 4000, fp)) {                if (strstr(line, "STREAM") && strstr(line, h.c_str())) {                    char *sp = strchr(line, ' ');                    string ip(line, sp);                    LOG(info) << "IP resolving " << h << " to " << ip;                    h = ip;                    break;                }            }            pclose(fp);        }    }

 void set_current_thread_data(detail::thread_data_base* new_data) {     boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);     if (current_thread_tls_key!=TLS_OUT_OF_INDEXES)     {         BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));     }     else     {         // If we attempted to set the data to a null pointer, don't flag an error.         // This happens at shutdown, where boost has a race between thread and         // process exit handlers.         BOOST_VERIFY(!new_data);         //boost::throw_exception(thread_resource_error());     } }

BOOST_LOG_API bool once_block_sentry::enter_once_block() const{    AcquireSRWLockExclusive(&g_OnceBlockMutex);    once_block_flag volatile& flag = m_Flag;    while (flag.status != once_block_flag::initialized)    {        if (flag.status == once_block_flag::uninitialized)        {            flag.status = once_block_flag::being_initialized;            ReleaseSRWLockExclusive(&g_OnceBlockMutex);            // Invoke the initializer block            return false;        }        else        {            while (flag.status == once_block_flag::being_initialized)            {                BOOST_VERIFY(SleepConditionVariableSRW(                    &g_OnceBlockCond, &g_OnceBlockMutex, INFINITE, 0));            }        }    }    ReleaseSRWLockExclusive(&g_OnceBlockMutex);    return true;}

 // reset buffer chain to initial state void disable() {     if (enabled) {         BOOST_VERIFY(&buffer_data == sink.chain_buffering(prev_buffer));         enabled = false;     } }

    int UDPSocket::recv(void * data, int size) {        int bytes;        struct sockaddr_storage saddr;        socklen_t length = sizeof (saddr);        BOOST_ASSERT(data != NULL);        BOOST_ASSERT(sock >= 0);        bytes = ::recvfrom(sock, data, size, 0, (struct sockaddr *) &saddr, &length);        // TODO: Implement status error (eg. Conn closed, ...)        if (bytes < 0)            throw ErrException("UDPSocket", "recvfrom");        if (bytes == 0) {            //Socket is now closed            BOOST_VERIFY(sock < 0);            return 0;        }        /**         * recv doesn't set the after-the-last byte to zero. We must do it to         * avoid some issues.         * (writing into a prefilled longer data buffer fucks everything up)         */        if (bytes < size)            ((char*) data)[bytes] = 0;        lastRecvAddr = SockAddress((const sockaddr *) &saddr);        return bytes;    }

voidPGMImageWriter::beginOfImage(int cols, int rows) {    _cols = cols;    _outputRow = pgm_allocrow(cols);    BOOST_VERIFY(_outputRow != NULL);    pgm_writepgminit(_output, cols, rows, 255, 1);}

 void release_shared_waiters(state_data old_state) {     if(old_state.shared_waiting || old_state.exclusive_waiting)     {         BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);     } }

        virtual void rebuild () {   // insert must not happen at this time            if (flavor == KGRAPH_LINEAR) {                BOOST_VERIFY(indexed_size == 0);                return;            }            if (entries.size() == indexed_size) return;            if (flavor == KGRAPH_LITE) {                indexed_size = 0;                delete kg_index;                kg_index = nullptr;                return;            }            KGraph *kg = nullptr;            if (entries.size() >= min_index_size) {                kg = KGraph::create();                LOG(info) << "Rebuilding index for " << entries.size() << " features.";                IndexOracle oracle(this, index_params_l1);                kg->build(oracle, index_params, NULL);                LOG(info) << "Swapping on new index...";            }            indexed_size = entries.size();            std::swap(kg, kg_index);            if (kg) {                delete kg;            }        }

void test_on_the_fly_merge (const Container & values){    using nested_container_type = typename Container::value_type;    std::vector<boost::iterator_range<typename nested_container_type::const_iterator>> ranges;    boost::for_each(values,        [& ranges] (const nested_container_type & values)        {            ranges.push_back(boost::make_iterator_range(values));        });    clock_t merge_time = clock();    auto merged_range = burst::merge(boost::make_iterator_range(ranges));    auto distance = static_cast<std::size_t>(std::distance(merged_range.begin(), merged_range.end()));    merge_time = clock() - merge_time;    BOOST_VERIFY    (        distance ==            std::accumulate(values.begin(), values.end(), 0ul,                [] (std::size_t current_value, const nested_container_type & vector)                {                    return current_value + vector.size();                })    );    std::cout << "Слияние на лету:" << std::endl;    std::cout << "/t" << static_cast<double>(merge_time) / CLOCKS_PER_SEC << std::endl;    std::cout << std::endl;}

voidSegmentFetcher::sendInterest(uint64_t segNum, const Interest& interest, bool isRetransmission){  weak_ptr<SegmentFetcher> weakSelf = m_this;  ++m_nSegmentsInFlight;  auto pendingInterest = m_face.expressInterest(interest,    [this, weakSelf] (const Interest& interest, const Data& data) {      afterSegmentReceivedCb(interest, data, weakSelf);    },    [this, weakSelf] (const Interest& interest, const lp::Nack& nack) {      afterNackReceivedCb(interest, nack, weakSelf);    },    nullptr);  auto timeout = m_options.useConstantInterestTimeout ? m_options.maxTimeout : getEstimatedRto();  auto timeoutEvent = m_scheduler.schedule(timeout, [this, interest, weakSelf] {    afterTimeoutCb(interest, weakSelf);  });  if (isRetransmission) {    updateRetransmittedSegment(segNum, pendingInterest, timeoutEvent);    return;  }  PendingSegment pendingSegment{SegmentState::FirstInterest, time::steady_clock::now(),                                pendingInterest, timeoutEvent};  bool isNew = m_pendingSegments.emplace(segNum, std::move(pendingSegment)).second;  BOOST_VERIFY(isNew);  m_highInterest = segNum;}

void JpegPayload::setMbz(boost::uint8_t mbz){    boost::uint_t<MBZ_BIT_SIZE>::fast MbzMaxValue =        boost::low_bits_mask_t<MBZ_BIT_SIZE>::sig_bits;    BOOST_VERIFY(mbz <= MbzMaxValue);    m_mbz = mbz;}

        void set_current_thread_data(detail::thread_data_base* new_data)        {            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);#if BOOST_PLAT_WINDOWS_RUNTIME            current_thread_data_base = new_data;#else            if (current_thread_tls_key != TLS_OUT_OF_INDEXES)            {                BOOST_VERIFY(TlsSetValue(current_thread_tls_key, new_data));            }            else            {                BOOST_VERIFY(false);                //boost::throw_exception(thread_resource_error());            }#endif        }

inline typename boost::log::basic_core< CharT >::record_type make_record(    boost::log::basic_attribute_set< CharT > const& src_attrs){    BOOST_VERIFY(!!aux::make_record_sink_holder< CharT >::instance); // to force sink registration    typedef boost::log::basic_core< CharT > core_type;    return core_type::get()->open_record(src_attrs);}

 void set_current_thread_data(detail::thread_data_base* new_data) {     boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);     if(current_thread_tls_key)         BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));     else         boost::throw_exception(thread_resource_error()); }

    void call_once(once_flag& flag,Function f)    {        static riakboost::uintmax_t const uninitialized_flag=BOOST_ONCE_INITIAL_FLAG_VALUE;        static riakboost::uintmax_t const being_initialized=uninitialized_flag+1;        riakboost::uintmax_t const epoch=flag.epoch;        riakboost::uintmax_t& this_thread_epoch=detail::get_once_per_thread_epoch();                if(epoch<this_thread_epoch)        {            pthread::pthread_mutex_scoped_lock lk(&detail::once_epoch_mutex);            while(flag.epoch<=being_initialized)            {                if(flag.epoch==uninitialized_flag)                {                    flag.epoch=being_initialized;#ifndef BOOST_NO_EXCEPTIONS                    try                    {#endif                        pthread::pthread_mutex_scoped_unlock relocker(&detail::once_epoch_mutex);                        f();#ifndef BOOST_NO_EXCEPTIONS                    }                    catch(...)                    {                        flag.epoch=uninitialized_flag;                        BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));                        throw;                    }#endif                    flag.epoch=--detail::once_global_epoch;                    BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));                }                else                {                    while(flag.epoch==being_initialized)                    {                        BOOST_VERIFY(!pthread_cond_wait(&detail::once_epoch_cv,&detail::once_epoch_mutex));                    }                }            }            this_thread_epoch=detail::once_global_epoch;        }    }

 void lock() {     boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);     while(is_locked)     {         BOOST_VERIFY(!pthread_cond_wait(&cond,&m));     }     is_locked=true; }

 void unlock() {     boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);     if(!--count)     {         is_locked=false;     }     BOOST_VERIFY(!pthread_cond_signal(&cond)); }

 void OverrideConfig (std::vector<std::string> const &overrides, Config *config) {     for (std::string const &D: overrides) {         size_t o = D.find("=");         if (o == D.npos || o == 0 || o + 1 >= D.size()) {             std::cerr << "Bad parameter: " << D << std::endl;             BOOST_VERIFY(0);         }         config->put<std::string>(D.substr(0, o), D.substr(o + 1));     } }