Main Page | Modules | Class Hierarchy | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Related Pages
src

switch_buffer.c File Reference


Data Structures

struct  switch_buffer

Enumerations

enum  switch_buffer_flag_t { SWITCH_BUFFER_FLAG_DYNAMIC = (1 << 0) }

Functions

switch_status_t switch_buffer_create (switch_memory_pool_t *pool, switch_buffer_t **buffer, switch_size_t max_len)
switch_status_t switch_buffer_create_dynamic (switch_buffer_t **buffer, switch_size_t blocksize, switch_size_t start_len, switch_size_t max_len)
void switch_buffer_add_mutex (switch_buffer_t *buffer, switch_mutex_t *mutex)
void switch_buffer_lock (switch_buffer_t *buffer)
switch_status_t switch_buffer_trylock (switch_buffer_t *buffer)
void switch_buffer_unlock (switch_buffer_t *buffer)
switch_size_t switch_buffer_len (switch_buffer_t *buffer)
switch_size_t switch_buffer_freespace (switch_buffer_t *buffer)
switch_size_t switch_buffer_inuse (switch_buffer_t *buffer)
switch_size_t switch_buffer_toss (switch_buffer_t *buffer, switch_size_t datalen)
void switch_buffer_set_loops (switch_buffer_t *buffer, int32_t loops)
switch_size_t switch_buffer_read_loop (switch_buffer_t *buffer, void *data, switch_size_t datalen)
switch_size_t switch_buffer_read (switch_buffer_t *buffer, void *data, switch_size_t datalen)
switch_size_t switch_buffer_write (switch_buffer_t *buffer, const void *data, switch_size_t datalen)
void switch_buffer_zero (switch_buffer_t *buffer)
switch_size_t switch_buffer_zwrite (switch_buffer_t *buffer, const void *data, switch_size_t datalen)
void switch_buffer_destroy (switch_buffer_t **buffer)
 Destroy the buffer.

Enumeration Type Documentation

enum switch_buffer_flag_t
 

Enumeration values:
SWITCH_BUFFER_FLAG_DYNAMIC  
00037              {
00038         SWITCH_BUFFER_FLAG_DYNAMIC = (1 << 0)
00039 } switch_buffer_flag_t;

Function Documentation

void switch_buffer_add_mutex (  switch_buffer_t *  buffer,
switch_mutex_t *  mutex
) 
  

00100 {
00101         buffer->mutex = mutex;
00102 }

switch_status_t switch_buffer_create (  switch_memory_pool_t *  pool,
switch_buffer_t **  buffer,
switch_size_t  max_len
) 
  

00056 {
00057         switch_buffer_t *new_buffer;
00058 
00059         if ((new_buffer = switch_core_alloc(pool, sizeof(switch_buffer_t))) != 0 && (new_buffer->data = switch_core_alloc(pool, max_len)) != 0) {
00060                 new_buffer->datalen = max_len;
00061                 new_buffer->id = buffer_id++;
00062                 new_buffer->head = new_buffer->data;
00063                 *buffer = new_buffer;
00064                 return SWITCH_STATUS_SUCCESS;
00065         }
00066         return SWITCH_STATUS_MEMERR;
00067 }

switch_status_t switch_buffer_create_dynamic (  switch_buffer_t **  buffer,
switch_size_t  blocksize,
switch_size_t  start_len,
switch_size_t  max_len
) 
  

00071 {
00072         switch_buffer_t *new_buffer;
00073 
00074         if ((new_buffer = malloc(sizeof(*new_buffer)))) {
00075                 memset(new_buffer, 0, sizeof(*new_buffer));
00076 
00077                 if (start_len) {
00078                         if (!(new_buffer->data = malloc(start_len))) {
00079                                 free(new_buffer);
00080                                 return SWITCH_STATUS_MEMERR;
00081                         }
00082                         memset(new_buffer->data, 0, start_len);
00083                 }
00084 
00085                 new_buffer->max_len = max_len;
00086                 new_buffer->datalen = start_len;
00087                 new_buffer->id = buffer_id++;
00088                 new_buffer->blocksize = blocksize;
00089                 new_buffer->head = new_buffer->data;
00090                 switch_set_flag(new_buffer, SWITCH_BUFFER_FLAG_DYNAMIC);
00091 
00092                 *buffer = new_buffer;
00093                 return SWITCH_STATUS_SUCCESS;
00094         }
00095 
00096         return SWITCH_STATUS_MEMERR;
00097 }

switch_size_t switch_buffer_freespace (  switch_buffer_t *  buffer  ) 
  

00132 {
00133         if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_DYNAMIC)) {
00134                 if (buffer->max_len) {
00135                         return (switch_size_t) (buffer->max_len - buffer->used);
00136                 }
00137                 return 1000000;
00138         }
00139 
00140         return (switch_size_t) (buffer->datalen - buffer->used);
00141 }

switch_size_t switch_buffer_inuse (  switch_buffer_t *  buffer  ) 
  

00144 {
00145         return buffer->used;
00146 }

switch_size_t switch_buffer_len (  switch_buffer_t *  buffer  ) 
  

00127 {
00128         return buffer->datalen;
00129 }

void switch_buffer_lock (  switch_buffer_t *  buffer  ) 
  

00105 {
00106         if (buffer->mutex) {
00107                 switch_mutex_lock(buffer->mutex);
00108         }
00109 }

Here is the call graph for this function:

switch_size_t switch_buffer_read (  switch_buffer_t *  buffer,
void *  data,
switch_size_t  datalen
) 
  

00190 {
00191         switch_size_t reading = 0;
00192 
00193         if (buffer->used < 1) {
00194                 buffer->used = 0;
00195                 return 0;
00196         } else if (buffer->used >= datalen) {
00197                 reading = datalen;
00198         } else {
00199                 reading = buffer->used;
00200         }
00201 
00202         memcpy(data, buffer->head, reading);
00203         buffer->used -= reading;
00204         buffer->head += reading;
00205 
00206         return reading;
00207 }

switch_size_t switch_buffer_read_loop (  switch_buffer_t *  buffer,
void *  data,
switch_size_t  datalen
) 
  

00173 {
00174         switch_size_t len;
00175         if ((len = switch_buffer_read(buffer, data, datalen)) == 0) {
00176                 if (buffer->loops > 0) {
00177                         buffer->loops--;
00178                 }
00179                 if (buffer->loops == 0) {
00180                         return 0;
00181                 }
00182                 buffer->head = buffer->data;
00183                 buffer->used = buffer->actually_used;
00184                 len = switch_buffer_read(buffer, data, datalen);
00185         }
00186         return len;
00187 }

Here is the call graph for this function:

void switch_buffer_set_loops (  switch_buffer_t *  buffer,
int32_t  loops
) 
  

00168 {
00169         buffer->loops = loops;
00170 }

switch_size_t switch_buffer_toss (  switch_buffer_t *  buffer,
switch_size_t  datalen
) 
  

00149 {
00150         switch_size_t reading = 0;
00151 
00152         if (buffer->used < 1) {
00153                 buffer->used = 0;
00154                 return 0;
00155         } else if (buffer->used >= datalen) {
00156                 reading = datalen;
00157         } else {
00158                 reading = buffer->used;
00159         }
00160 
00161         buffer->used -= reading;
00162         buffer->head += reading;
00163 
00164         return buffer->used;
00165 }

switch_status_t switch_buffer_trylock (  switch_buffer_t *  buffer  ) 
  

00112 {
00113         if (buffer->mutex) {
00114                 return switch_mutex_lock(buffer->mutex);
00115         }
00116         return SWITCH_STATUS_FALSE;
00117 }

Here is the call graph for this function:

void switch_buffer_unlock (  switch_buffer_t *  buffer  ) 
  

00120 {
00121         if (buffer->mutex) {
00122                 switch_mutex_unlock(buffer->mutex);
00123         }
00124 }

Here is the call graph for this function:

switch_size_t switch_buffer_write (  switch_buffer_t *  buffer,
const void *  data,
switch_size_t  datalen
) 
  

00210 {
00211         switch_size_t freespace, actual_freespace;
00212 
00213         switch_assert(buffer->data != NULL);
00214 
00215         if (!datalen) {
00216                 return buffer->used;
00217         }
00218 
00219         actual_freespace = buffer->datalen - buffer->actually_used;
00220 
00221         if (actual_freespace < datalen) {
00222                 memmove(buffer->data, buffer->head, buffer->used);
00223                 buffer->head = buffer->data;
00224                 buffer->actually_used = buffer->used;
00225         }
00226 
00227         freespace = buffer->datalen - buffer->used;
00228 
00229         if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_DYNAMIC)) {
00230                 if (freespace < datalen && (!buffer->max_len || (buffer->used + datalen <= buffer->max_len))) {
00231                         switch_size_t new_size, new_block_size;
00232 
00233                         new_size = buffer->datalen + datalen;
00234                         new_block_size = buffer->datalen + buffer->blocksize;
00235 
00236                         if (new_block_size > new_size) {
00237                                 new_size = new_block_size;
00238                         }
00239                         buffer->head = buffer->data;
00240                         if (!(buffer->data = realloc(buffer->data, new_size))) {
00241                                 return 0;
00242                         }
00243                         buffer->head = buffer->data;
00244                         buffer->datalen = new_size;
00245                 }
00246         }
00247 
00248         freespace = buffer->datalen - buffer->used;
00249 
00250         if (freespace < datalen) {
00251                 return 0;
00252         }
00253 
00254         memcpy(buffer->head + buffer->used, data, datalen);
00255         buffer->used += datalen;
00256         buffer->actually_used += datalen;
00257         return buffer->used;
00258 }

void switch_buffer_zero (  switch_buffer_t *  buffer  ) 
  

00261 {
00262         switch_assert(buffer->data != NULL);
00263 
00264         buffer->used = 0;
00265         buffer->actually_used = 0;
00266         buffer->head = buffer->data;
00267 }

switch_size_t switch_buffer_zwrite (  switch_buffer_t *  buffer,
const void *  data,
switch_size_t  datalen
) 
  

00270 {
00271         switch_size_t w;
00272 
00273         if (!(w = switch_buffer_write(buffer, data, datalen))) {
00274                 switch_buffer_zero(buffer);
00275                 return switch_buffer_write(buffer, data, datalen);
00276         }
00277 
00278         return w;
00279 }

Here is the call graph for this function:

Generated on Mon May 26 22:06:51 2008 for FreeSWITCH by  doxygen 1.3.9.1