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;
    }

void
PGMImageWriter::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;
}

void
SegmentFetcher::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));
     }
 }