本文整理汇总了C++中buffer_size函数的典型用法代码示例。如果您正苦于以下问题:C++ buffer_size函数的具体用法?C++ buffer_size怎么用?C++ buffer_size使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了buffer_size函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: consume
// Consume the specified number of bytes from the buffers.
void consume(std::size_t size)
{
// Remove buffers from the start until the specified size is reached.
while (size > 0 && !at_end_)
{
if (buffer_size(first_) <= size)
{
size -= buffer_size(first_);
if (begin_remainder_ == buffers_.end())
at_end_ = true;
else
first_ = *begin_remainder_++;
}
else
{
first_ = first_ + size;
size = 0;
}
}
// Remove any more empty buffers at the start.
while (!at_end_ && buffer_size(first_) == 0)
{
if (begin_remainder_ == buffers_.end())
at_end_ = true;
else
first_ = *begin_remainder_++;
}
}
示例2: buffer
/// Create a new non-modifiable buffer from an existing buffer.
inline const_buffer_container_1 buffer(const const_buffer& b,
std::size_t max_size_in_bytes)
{
return const_buffer_container_1(
const_buffer(buffer_cast<const void*>(b),
buffer_size(b) < max_size_in_bytes
? buffer_size(b) : max_size_in_bytes));
}
示例3: const_buffer
/**
* @relates const_buffer
*/
inline const_buffer operator+(std::size_t start, const const_buffer& b)
{
if (start > buffer_size(b))
return const_buffer();
const char* new_data = buffer_cast<const char*>(b) + start;
std::size_t new_size = buffer_size(b) - start;
return const_buffer(new_data, new_size);
}
示例4: mutable_buffer
/**
* @relates mutable_buffer
*/
inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
{
if (start > buffer_size(b))
return mutable_buffer();
char* new_data = buffer_cast<char*>(b) + start;
std::size_t new_size = buffer_size(b) - start;
return mutable_buffer(new_data, new_size);
}
示例5: need_wrap
static bool need_wrap(struct buffer * buffer)
{
if (buffer == &primary_buf)
return buffer_size(buffer) + indent_size() == max_columns;
else
return (buffer_size(&primary_buf) + buffer_size(&tag_buf)
+ buffer_size(buffer) + indent_size()) >= max_columns;
}
示例6: resize
void Attribute::resize(Mesh *mesh, AttributePrimitive prim, bool reserve_only)
{
if(reserve_only) {
buffer.reserve(buffer_size(mesh, prim));
}
else {
buffer.resize(buffer_size(mesh, prim), 0);
}
}
示例7: save
mutable_buffer save(mutable_buffer& buffer, const mutable_buffer& v)
{
if(buffer_size(buffer) < buffer_size(v)) {
throw serialization_error("not enough buffer");
}
memcpy(buffer_cast<uint8*>(buffer), buffer_cast<uint8*>(v), buffer_size(v));
return buffer + buffer_size(v);
}
示例8: write_server_handle
/*
* pconn is proxy --> server, and has no buffer.
*/
int write_server_handle( conn_t *pconn )
{
log_message( LOG_DEBUG, "in write_server_handle" );
//如果client_conn已经关闭,还是需要把剩余数据发送给server端
if ( NULL == pconn->write_buffer ) {
log_message( LOG_ERROR, "write_server_handle: write_buffer is NULL." );
return -1;
}
if ( 1 == pconn->write_closed ) {
log_message( LOG_WARNING, "try writing to server[%s] fd[%d], but it closed write",
inet_ntoa(pconn->addr.sin_addr), pconn->fd );
return -1;
}
int bytes;
bytes = write_buffer( pconn->fd, pconn->write_buffer );
log_message( LOG_DEBUG, "send to server[%s:%d] %d bytes.\n", inet_ntoa(pconn->addr.sin_addr), ntohs(pconn->addr.sin_port), bytes );
if ( g_errno < 0 ) { //写出错
CONN_CLOSE_WRITE( pconn );
if ( 1 == pconn->read_closed )
return -1;
}
else {
if ( 0==buffer_size(pconn->write_buffer) && //发送完缓冲区中的数据
( NULL==pconn->server_conn || //并且客户端不会再有数据过来
1 == pconn->server_conn->read_closed ) ) {
CONN_CLOSE_WRITE( pconn );
if ( 1 == pconn->read_closed )
return -1;
}
}
/*
* it's very important
*/
uint32_t clientf = 0, serverf = 0;
//写缓存中还有数据
if ( 0 == pconn->write_closed && buffer_size( pconn->write_buffer ) > 0 )
serverf |= EPOLLOUT;
//读缓存未满并且未关闭读
if ( 0 == pconn->read_closed && buffer_size( pconn->read_buffer ) < MAXBUFFSIZE )
serverf |= EPOLLIN; //继续侦听读事件
epoll_mod_connection( pconn, serverf );
conn_t *pclie_conn;
if ( NULL != ( pclie_conn = pconn->server_conn ) ) {
if ( 0 == pclie_conn->write_closed && buffer_size( pclie_conn->write_buffer ) > 0 )
clientf |= EPOLLOUT;
if ( 0 == pclie_conn->read_closed && buffer_size( pclie_conn->read_buffer ) < MAXBUFFSIZE )
clientf |= EPOLLIN;
epoll_mod_connection( pclie_conn, clientf );
}
return TRUE;
}
示例9: switch
bool Lexer::skipComments()
{
// We need to ensure that we have enough characters in the buffer.
switch (buffer_size()) {
case 0:
buffer_put(m_input->get());
case 1:
buffer_put(m_input->get());
case 2:
buffer_put(m_input->get());
case 3:
buffer_put(m_input->get());
}
// We have a comment iff it begins with '<!--' sequence.
if (!(buffer_at(0) == '<' &&
buffer_at(1) == '!' &&
buffer_at(2) == '-' &&
buffer_at(3) == '-'))
{
return false;
}
buffer_pop();
buffer_pop();
buffer_pop();
buffer_pop();
for (;;) {
// TODO: Handle unclosed comments.
// As above, we enusre that we have enough characters available.
switch (buffer_size()) {
case 0:
buffer_put(m_input->get());
case 1:
buffer_put(m_input->get());
case 2:
buffer_put(m_input->get());
}
// The comment ends only with the '-->' sequence.
if (buffer_at(0) == '-' &&
buffer_at(1) == '-' &&
buffer_at(2) == '>')
{
buffer_pop();
buffer_pop();
buffer_pop();
break;
}
buffer_pop();
}
return true;
}
示例10: content
static void content(void)
{
char current;
/*
* We should get one character at a time.
*/
assert(strlen(yytext) == 1);
current = yytext[0];
if (current == EOF)
return;
if (is_newline(current)) {
newline();
return;
}
buffer_push_char(current_buf, current);
/*
* Forcing newline changes 'text' so lets do it after we've pushed
* it to the buffer.
*/
if (wrap_long_lines && need_wrap(current_buf)) {
struct buffer tmp;
buffer_init(&tmp, buffer_size(current_buf));
/*
* Find last character that was not whitespace
*/
for (;;) {
int c;
if (buffer_size(current_buf) == 0)
break;
c = buffer_pop_char(current_buf);
if (is_whitespace(c)) {
/*
* Do not push whitespace because it would appear
* after the newline.
*/
break;
}
/*
* Characters are put in tmp buffer in reverse order.
*/
buffer_push_char(&tmp, c);
}
force_newline_for_wrap(current_buf);
/*
* Restore non-wrapped text into buffer.
*/
while (buffer_size(&tmp) > 0) {
buffer_push_char(current_buf, buffer_pop_char(&tmp));
}
buffer_release(&tmp);
}
}
示例11: reserve
void Attribute::reserve(int numverts, int numtris, int numsteps, int numcurves, int numkeys, bool resize)
{
if (resize) {
buffer.resize(buffer_size(numverts, numtris, numsteps, numcurves, numkeys), 0);
}
else {
buffer.reserve(buffer_size(numverts, numtris, numsteps, numcurves, numkeys));
}
}
示例12: load
const_buffer load(const_buffer& buffer, const_buffer& v)
{
if(buffer_size(buffer) < buffer_size(v)) {
throw serialization_error("not enough buffer");
}
memcpy(const_cast<uint8*>(buffer_cast<const uint8*>(v))
, buffer_cast<const uint8*>(buffer), buffer_size(v));
return buffer + buffer_size(v);
}
示例13: equal
bool equal(const consuming_buffers_iterator& other) const
{
if (at_end_ && other.at_end_)
return true;
return !at_end_ && !other.at_end_
&& buffer_cast<const void*>(first_)
== buffer_cast<const void*>(other.first_)
&& buffer_size(first_) == buffer_size(other.first_)
&& begin_remainder_ == other.begin_remainder_
&& end_remainder_ == other.end_remainder_;
}
示例14: vmn_str_prealloc
/**
* VMNative: string_prealloc( workshop , newsize )
* Accepts a workshop argument and a number. The newsize is the size to
* reallocate the workshop buffer to. Preallocate buffer for best performance.
*/
static bool vmn_str_prealloc(VM * vm, VMArg * arg, int argc) {
VMLibData * data;
Buffer * buffer;
int newSize;
/* check for proper number of arguments */
if(argc != 2) {
vm_set_err(vm, VMERR_INCORRECT_NUMARGS);
return false;
}
/* check argument 1 major type */
if(vmarg_type(arg[0]) != TYPE_LIBDATA) {
vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
return false;
}
/* extract the libdata from the argument */
data = vmarg_libdata(arg[0]);
/* check libdata type */
if(!vmlibdata_is_type(data, LIBSTR_STRING_TYPE, LIBSTR_STRING_TYPE_LEN)) {
vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
return false;
}
/* check argument 2 type */
if(vmarg_type(arg[1]) != TYPE_NUMBER) {
vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
return false;
}
newSize = (int)vmarg_number(arg[1], NULL);
/* check buffer size range */
if(newSize < 1) {
vm_set_err(vm, VMERR_ARGUMENT_OUT_OF_RANGE);
return false;
}
/* extract the workshop */
buffer = vmlibdata_data(data);
/* can't make it smaller, only bigger */
buffer_resize(buffer, newSize >= buffer_size(buffer)
? newSize : buffer_size(buffer));
/* push null result */
vmarg_push_null(vm);
/* this function does return a value */
return true;
}
示例15: stream_check_test
void stream_check_test(Buffer_Set *buffers, void *scratch, int scratch_size){
int i, page_size, size;
size = buffer_size(&buffers->buffer);
{
int size2;
size2 = buffer_size(&buffers->gap_buffer);
hard_assert_4tech(size == size2);
size2 = buffer_size(&buffers->multi_gap_buffer);
hard_assert_4tech(size == size2);
size2 = buffer_size(&buffers->rope_buffer);
hard_assert_4tech(size == size2);
}
page_size = 1 << 10;
char *page_1 = (char*)scratch;
char *page_2 = page_1 + page_size;
scratch_size -= page_size*2;
hard_assert_4tech(scratch_size > 0);
for (i = 0; i < size; i += page_size){
int end = i + page_size;
if (end > size) end = size;
buffer_stringify(&buffers->buffer, i, end, page_1);
buffer_stringify(&buffers->gap_buffer, i, end, page_2);
page_compare(page_1, page_2, page_size);
buffer_stringify(&buffers->multi_gap_buffer, i, end, page_2);
page_compare(page_1, page_2, page_size);
buffer_stringify(&buffers->rope_buffer, i, end, page_2);
page_compare(page_1, page_2, page_size);
}
for (i = size-1; i > 0; i -= page_size){
int end = i - page_size;
if (end < 0) end = 0;
buffer_backify(&buffers->buffer, i, end, page_1);
buffer_backify(&buffers->gap_buffer, i, end, page_2);
page_compare(page_1, page_2, page_size);
buffer_backify(&buffers->multi_gap_buffer, i, end, page_2);
page_compare(page_1, page_2, page_size);
buffer_backify(&buffers->rope_buffer, i, end, page_2);
page_compare(page_1, page_2, page_size);
}
}