C++ buf_t::size方法代码示例

//
// MSG_CompressMinilzo
//
bool MSG_CompressMinilzo (buf_t &buf, size_t start_offset, size_t write_gap)
{
	if(buf.size() < MINILZO_COMPRESS_MINPACKETSIZE)
		return false;

	lzo_uint outlen = OUT_LEN(buf.maxsize() - start_offset - write_gap);
	size_t total_len = outlen + start_offset + write_gap;

	if(compressed.maxsize() < total_len)
		compressed.resize(total_len);

	int r = lzo1x_1_compress (buf.ptr() + start_offset,
							  buf.size() - start_offset,
							  compressed.ptr() + start_offset + write_gap,
							  &outlen,
							  wrkmem);

	// worth the effort?
	if(r != LZO_E_OK || outlen >= (buf.size() - start_offset - write_gap))
		return false;

	memcpy(compressed.ptr(), buf.ptr(), start_offset);

	SZ_Clear(&buf);
	MSG_WriteChunk(&buf, compressed.ptr(), outlen + start_offset + write_gap);

	return true;
}

      I merge_n_adaptive(I f0, DifferenceType<I> n0,
                         I f1, DifferenceType<I> n1,
                         buf_t<I>& buf, Comp& comp, Proj& proj) {
        if (n0 <= buf.size()) {
          if (!n0 || !n1) {
            return __stl2::next(f0, n0 + n1);
          }
          return fsort::merge_n_with_buffer(f0, n0, f1, n1, buf, comp, proj);
        }
        I f0_0, f0_1, f1_0, f1_1;
        DifferenceType<I> n0_0, n0_1, n1_0, n1_1;

        if (n0 < n1) {
                 fsort::merge_n_step_0(f0, n0, f1, n1, comp, proj,
                                       f0_0, n0_0, f0_1, n0_1,
                                       f1_0, n1_0, f1_1, n1_1);
        } else {
                 fsort::merge_n_step_1(f0, n0, f1, n1, comp, proj,
                                       f0_0, n0_0, f0_1, n0_1,
                                       f1_0, n1_0, f1_1, n1_1);
        }
               fsort::merge_n_adaptive(f0_0, n0_0, f0_1, n0_1,
                                       buf, comp, proj);
        return fsort::merge_n_adaptive(f1_0, n1_0, f1_1, n1_1,
                                       buf, comp, proj);
      }

void NET_SendPacket (buf_t &buf, netadr_t &to)
{
    int                   ret;
    struct sockaddr_in    addr;

    NetadrToSockadr (&to, &addr);

	ret = sendto (net_socket, (const char *)buf.ptr(), buf.size(), 0, (struct sockaddr *)&addr, sizeof(addr));

	buf.clear();

    if (ret == -1)
    {
#ifdef _WIN32
          int err = WSAGetLastError();

          // wouldblock is silent
          if (err == WSAEWOULDBLOCK)
              return;
#else
          if (errno == EWOULDBLOCK)
              return;
          if (errno == ECONNREFUSED)
              return;
          Printf (PRINT_HIGH, "NET_SendPacket: %s\n", strerror(errno));
#endif
    }
}

    requires
    models::Permutable<I>
    ext::range<I>
    forward(I first, difference_type_t<I> n,
            buf_t<I>& buf, Pred& pred, Proj& proj)
    {
        // Precondition: !pred(proj(*first)))
        STL2_ASSUME(n > 0);

        auto middle = __stl2::next(first);
        if (n == difference_type_t<I>(1)) {
            return {__stl2::move(first), __stl2::move(middle)};
        }
        // n >= 2

        if (n <= buf.size()) {
            return stable_part::forward_buffer(
                       __stl2::move(first), __stl2::move(middle),
                       n, buf, pred, proj);
        }

        const auto half_n = n / 2;
        auto res1 = stable_part::forward(__stl2::move(first), half_n, buf, pred, proj);
        auto res2 = stable_part::forward_reduce(res1.end(), n - half_n, buf, pred, proj);
        auto pp = __stl2::rotate(__stl2::move(res1.begin()),
                                 __stl2::move(res1.end()),
                                 __stl2::move(res2.begin())).begin();
        return {__stl2::move(pp), __stl2::move(res2.end())};
    }

    requires
    models::Permutable<I>
    I bidirectional(I first, I last, difference_type_t<I> n,
                    buf_t<I>& buf, Pred& pred, Proj& proj)
    {
        // Precondition: !pred(proj(*first))
        // Precondition: pred(proj(*last))
        // Precondition: n == distance(first, last)
        STL2_ASSUME(n >= difference_type_t<I>(1));

        if (n == difference_type_t<I>(1)) {
            __stl2::iter_swap(first, last);
            return last;
        }
        // n >= 2
        if (n <= buf.size()) {
            return stable_part::bidirectional_buffer(
                       __stl2::move(first), __stl2::move(last),
                       n, buf, pred, proj);
        }

        const auto half_n = n / 2;
        auto middle = __stl2::next(first, half_n);
        auto pp1 = stable_part::bidirectional_reduce_back(
                       __stl2::move(first), middle, half_n, buf, pred, proj);
        auto pp2 = stable_part::bidirectional_reduce_front(
                       middle, __stl2::move(last), n - half_n, buf, pred, proj);

        return __stl2::rotate(__stl2::move(pp1), __stl2::move(middle),
                              __stl2::move(pp2)).begin();
    }

    requires
    models::Permutable<I>
    I bidirectional_buffer(I first, I last, difference_type_t<I> n,
                           buf_t<I>& buf, Pred& pred, Proj& proj)
    {
        // Precondition: !pred(proj(*first))
        // Precondition: pred(proj(*last))
        // Precondition: n == distance(first, last)
        STL2_ASSUME(n >= 2);
        STL2_ASSUME(n <= buf.size());

        // Move the false values into the temporary buffer
        // and the true values to the front of the sequence.
        auto&& vec = detail::make_temporary_vector(buf);
        vec.push_back(__stl2::iter_move(first));
        auto middle = __stl2::next(first);
        middle = __stl2::partition_move(__stl2::move(middle), last,
                                        __stl2::move(first),
                                        __stl2::back_inserter(vec),
                                        __stl2::ref(pred),
                                        __stl2::ref(proj)).out1();
        *middle = __stl2::iter_move(last);
        ++middle;
        __stl2::move(vec, middle);
        return middle;
    }

//
// SV_CompressPacket
//
// [Russell] - reason this was failing is because of huffman routines, so just
// use minilzo for now (cuts a packet size down by roughly 45%), huffman is the
// if 0'd sections
void SV_CompressPacket(buf_t &send, unsigned int reserved, client_t *cl)
{
	if(plain.maxsize() < send.maxsize())
		plain.resize(send.maxsize());
	
	plain.setcursize(send.size());
	
	memcpy(plain.ptr(), send.ptr(), send.size());

	byte method = 0;

	int need_gap = 2; // for svc_compressed and method, below
#if 0
	if(MSG_CompressAdaptive(cl->compressor.get_codec(), send, reserved, need_gap))
	{
		reserved += need_gap;
		need_gap = 0;

		method |= adaptive_mask;

		if(cl->compressor.get_codec_id())
			method |= adaptive_select_mask;
	}
#endif
	DPrintf("SV_CompressPacket stage 2: %x %d\n", (int)method, (int)send.size());

	if(MSG_CompressMinilzo(send, reserved, need_gap))
		method |= minilzo_mask;

	if((method & adaptive_mask) || (method & minilzo_mask))
	{
#if 0
		if(cl->compressor.packet_sent(cl->sequence - 1, plain.ptr() + sizeof(int), plain.size() - sizeof(int)))
			method |= adaptive_record_mask;
#endif
		send.ptr()[sizeof(int)] = svc_compressed;
		send.ptr()[sizeof(int) + 1] = method;
	}
	DPrintf("SV_CompressPacket %x %d\n", (int)method, (int)send.size());

}

 void stable_sort_adaptive(I first, I last, buf_t<I>& buf, C &comp, P &proj) {
     auto len = DifferenceType<I>((last - first + 1) / 2);
     auto middle = first + len;
     if (len > buf.size()) {
         ssort::stable_sort_adaptive(first, middle, buf, comp, proj);
         ssort::stable_sort_adaptive(middle, last, buf, comp, proj);
     } else {
         ssort::merge_sort_with_buffer(first, middle, buf, comp, proj);
         ssort::merge_sort_with_buffer(middle, last, buf, comp, proj);
     }
     detail::merge_adaptive(first, middle, last,
                            middle - first, last - middle, buf,
                            __stl2::ref(comp), __stl2::ref(proj));
 }

//
// MSG_CompressAdaptive
//
bool MSG_CompressAdaptive (huffman &huff, buf_t &buf, size_t start_offset, size_t write_gap)
{
	size_t outlen = OUT_LEN(buf.maxsize() - start_offset - write_gap);
	size_t total_len = outlen + start_offset + write_gap;

	if(compressed.maxsize() < total_len)
		compressed.resize(total_len);

	bool r = huff.compress (buf.ptr() + start_offset,
							  buf.size() - start_offset,
							  compressed.ptr() + start_offset + write_gap,
							  outlen);

	// worth the effort?
	if(!r || outlen >= (buf.size() - start_offset - write_gap))
		return false;

	memcpy(compressed.ptr(), buf.ptr(), start_offset);

	SZ_Clear(&buf);
	MSG_WriteChunk(&buf, compressed.ptr(), outlen + start_offset + write_gap);

	return true;
}

 inline I merge_n_with_buffer(I f0, DifferenceType<I> n0,
                              I f1, DifferenceType<I> n1,
                              buf_t<I>& buf, Comp& comp, Proj& proj) {
   STL2_ASSUME(n0 <= buf.size());
   auto&& vec = make_temporary_vector(buf);
   __stl2::move(__stl2::make_counted_iterator(f0, n0),
                __stl2::default_sentinel{},
                __stl2::back_inserter(vec));
   return __stl2::merge_move(
     vec.begin(), vec.end(),
     __stl2::make_counted_iterator(__stl2::move(f1), n1),
     __stl2::default_sentinel{},
     __stl2::move(f0), __stl2::ref(comp),
     __stl2::ref(proj), __stl2::ref(proj)).out();
 }

    requires
    models::Permutable<I>
    ext::range<I>
    forward_buffer(I first, I next, difference_type_t<I> n,
                   buf_t<I>& buf, Pred& pred, Proj& proj)
    {
        // Precondition: !pred(proj(*first)))
        // Precondition: __stl2::next(first) == next
        STL2_ASSUME(n >= 2);
        STL2_ASSUME(n <= buf.size());

        auto&& vec = detail::make_temporary_vector(buf);
        vec.push_back(__stl2::iter_move(first));
        auto counted = __stl2::make_counted_iterator(
                           ext::uncounted(next), n - 1);
        auto pp = __stl2::partition_move(
                      __stl2::move(counted), default_sentinel{},
                      __stl2::move(first), __stl2::back_inserter(vec),
                      __stl2::ref(pred), __stl2::ref(proj)).out1();
        auto last = __stl2::move(vec, pp).out();
        return {__stl2::move(pp), __stl2::move(last)};
    }

void NET_SendPacket (buf_t &buf, netadr_t &to)
{
    int                   ret;
    struct sockaddr_in    addr;

	// [SL] 2011-07-06 - Don't try to send a packet if we're not really connected
	// (eg, a netdemo is being played back)
	if (simulated_connection)
	{
		buf.clear();
		return;
	}

    NetadrToSockadr (&to, &addr);

	ret = sendto (inet_socket, (const char *)buf.ptr(), buf.size(), 0, (struct sockaddr *)&addr, sizeof(addr));

	buf.clear();

    if (ret == -1)
    {
#ifdef _WIN32
          int err = WSAGetLastError();

          // wouldblock is silent
          if (err == WSAEWOULDBLOCK)
              return;
#else
          if (errno == EWOULDBLOCK)
              return;
          if (errno == ECONNREFUSED)
              return;
          Printf (PRINT_HIGH, "NET_SendPacket: %s\n", strerror(errno));
#endif
    }
}

 size_t         size() const  { return buf.size(); }