← Back to branch summary

~certify-web-dev/twisted/certify-trunk

« back to all changes in this revision

Viewing changes to sandbox/cReactor/cReactorBuffer.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2004-06-21 22:01:11 UTC
  • mto: (2.2.3 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20040621220111-vkf909euqnyrp3nr
Tags: upstream-1.3.0
Import upstream version 1.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
sandbox/cReactor/cReactorBuffer.c
 
1
/*
 
2
 * Twisted, the Framework of Your Internet
 
3
 * Copyright (C) 2001-2002 Matthew W. Lefkowitz
 
4
 * 
 
5
 * This library is free software; you can redistribute it and/or
 
6
 * modify it under the terms of version 2.1 of the GNU Lesser General Public
 
7
 * License as published by the Free Software Foundation.
 
8
 * 
 
9
 * This library is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * Lesser General Public License for more details.
 
13
 * 
 
14
 * You should have received a copy of the GNU Lesser General Public
 
15
 * License along with this library; if not, write to the Free Software
 
16
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * 
 
18
 */
 
19
/* cReactorBuffer.c - a simple read/write buffer. */
 
20
 
 
21
/* includes */
 
22
#include "cReactor.h"
 
23
 
 
24
struct _cReactorBuffer
 
25
{
 
26
    unsigned char *     memory;
 
27
    unsigned int        memory_size;
 
28
    unsigned char *     read_ptr;
 
29
    unsigned char *     write_ptr;
 
30
};
 
31
 
 
32
 
 
33
cReactorBuffer *
 
34
cReactorBuffer_New(unsigned int size)
 
35
{
 
36
    cReactorBuffer *buf;
 
37
 
 
38
    buf = (cReactorBuffer *)malloc(sizeof(cReactorBuffer));
 
39
    buf->memory         = (unsigned char *)malloc(size);
 
40
    buf->memory_size    = size;
 
41
    buf->read_ptr       = buf->memory;
 
42
    buf->write_ptr      = buf->memory;
 
43
 
 
44
    return buf;
 
45
}
 
46
 
 
47
 
 
48
void
 
49
cReactorBuffer_Destroy(cReactorBuffer *buffer)
 
50
{
 
51
    if (buffer)
 
52
    {
 
53
        free(buffer->memory);
 
54
        free(buffer);
 
55
    }
 
56
}
 
57
 
 
58
 
 
59
void
 
60
cReactorBuffer_Write(cReactorBuffer *buffer, const void *data, unsigned int size)
 
61
{
 
62
    unsigned int used;
 
63
    unsigned int avail;
 
64
    unsigned int pre_read;
 
65
    unsigned int new_size;
 
66
    unsigned char *new_mem;
 
67
 
 
68
    /* Determine how much is used. */
 
69
    used = buffer->write_ptr - buffer->read_ptr;
 
70
 
 
71
    /* Determine how much space is currently available. */
 
72
    avail = (buffer->memory + buffer->memory_size) - buffer->write_ptr;
 
73
 
 
74
    /* Check if we do not have enough space to write. */
 
75
    if (avail < size)
 
76
    {
 
77
        /* If there is enough space between the start of the memory block and the
 
78
         * read pointer we can slide the buffer back towards the memory block
 
79
         * start.
 
80
         */
 
81
        pre_read = buffer->read_ptr - buffer->memory;
 
82
        if ((avail + pre_read) >= size)
 
83
        {
 
84
            /* Sliding will give us the space. */
 
85
            memmove(buffer->memory, buffer->read_ptr, used);
 
86
            buffer->read_ptr        = buffer->memory;
 
87
            buffer->write_ptr      -= pre_read;
 
88
        }
 
89
        else
 
90
        {
 
91
            /* We have to allocate a new buffer. */
 
92
            new_size  = (buffer->memory_size * 2) + size;
 
93
            new_mem   = (unsigned char *)malloc(new_size);
 
94
            memcpy(new_mem, buffer->read_ptr, used); 
 
95
 
 
96
            buffer->write_ptr   = new_mem + used;
 
97
            buffer->read_ptr    = new_mem;
 
98
            buffer->memory_size = new_size;
 
99
    
 
100
            free(buffer->memory);
 
101
            buffer->memory = new_mem;
 
102
        }
 
103
    }
 
104
 
 
105
    /* Write. */
 
106
    memcpy(buffer->write_ptr, data, size);
 
107
    buffer->write_ptr += size;
 
108
 
 
109
}
 
110
 
 
111
 
 
112
unsigned int
 
113
cReactorBuffer_DataAvailable(cReactorBuffer *buffer)
 
114
{
 
115
    /* Allow NULL buffers. */
 
116
    return (buffer 
 
117
            ? (buffer->write_ptr - buffer->read_ptr)
 
118
            : 0);
 
119
}
 
120
 
 
121
 
 
122
const unsigned char *
 
123
cReactorBuffer_GetPtr(cReactorBuffer *buffer)
 
124
{
 
125
    return buffer->read_ptr;
 
126
}
 
127
 
 
128
void
 
129
cReactorBuffer_Seek(cReactorBuffer *buffer, unsigned int forward)
 
130
{
 
131
    unsigned int avail;
 
132
 
 
133
    avail = (buffer->write_ptr - buffer->read_ptr);
 
134
    if (forward >= avail)
 
135
    {
 
136
        buffer->write_ptr   = buffer->memory;
 
137
        buffer->read_ptr    = buffer->memory;
 
138
    }
 
139
    else
 
140
    {
 
141
        buffer->read_ptr += forward;
 
142
    }
 
143
}
 
144
 
 
145
/* vim: set sts=4 sw=4: */