C++ buf_t类代码示例

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

 bool buf_t::append_from_buf( 
   const buf_t &other, 
   int start,
   int len
   ) 
 {
   // find how much data is available in other buf from start point.
   
   int actual_len = other.get_data_length() - start;
   
   if( actual_len < 0 )
   {
     // there is no data to copy - just return success.
     return true;
   }
   
   int copy_len = actual_len;
   
   // if he wants to copy a maximum number of bytes get the minimum of
   // actual length and len.
   
   if( len!=-1 )
   {
     if( len<actual_len )
       copy_len = len;
   }
   
   // ok, it is safe now, append it
   
   return append_from_data( other.get_data() + start, copy_len );
 } 

		void read(void *data, size_t bytes)
		{
			if (pos==typename buf_t::const_iterator())
				pos=buffer.begin();

			if (buffer.end()-pos < bytes)
				throw std::out_of_range("Premature end of buffer");

			std::copy(pos, pos+bytes, static_cast<char*>(data));
			pos += bytes;
		}

obj deserialize_as(const buf_t& buffer, obj result = obj())
{
    if (!buffer.empty())
        make_deserializer(buffer)(result);

    return result;
}

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

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

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

TarHeader::EntryType UnTar::entry(buf_t& buf, int accepted_types, bool skip_apple_resource_forks)
{
    do {

        m_header.reset();
        read(*m_header, TarHeader::HeaderLen);
        m_header.analyze();

        // this is the only valid exit condition from reading a tar archive - end header reached
        if (m_header.is_end()) return TarHeader::Unknown;

        if (m_header.type() == TarHeader::File) {

            // make sure we reserve space for at least one more character than the file size
            // (to cheaply add a 0 byte if the user wants to)
            buf.reserve(m_header.filesize() + 1);

            // resize the buffer to be able to read the file size
            buf.resize(m_header.filesize());

            // read the file into the buffer
            read(&buf[0], m_header.filesize());

            // check if we have to skip some padding bytes (tar files have a block size of 512)
            size_t padding = (TarHeader::HeaderLen - (m_header.filesize() % TarHeader::HeaderLen)) % TarHeader::HeaderLen;

            if (padding) {
                // this invalidates the (raw) header, but it is a handy buffer to read up to 512 bytes into here
                read(*m_header, padding);
            }

        }

    } while ((m_header.type() & accepted_types) == 0 || (skip_apple_resource_forks && CDDB::begins_with(m_header.filename(), ("./._"))));

    return m_header.type();
}

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

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

//
// 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());

}

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

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