source: orange/source/orange/slist.hpp @ 10390:bcf979ac3351

Revision 10390:bcf979ac3351, 5.2 KB checked in by Ales Erjavec <ales.erjavec@…>, 2 years ago (diff)

Using memcpy to write data to buffer.

Line 
1/*
2    This file is part of Orange.
3   
4    Copyright 1996-2010 Faculty of Computer and Information Science, University of Ljubljana
5    Contact: janez.demsar@fri.uni-lj.si
6
7    Orange is free software: you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation, either version 3 of the License, or
10    (at your option) any later version.
11
12    Orange is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with Orange.  If not, see <http://www.gnu.org/licenses/>.
19*/
20
21
22#ifndef __SLIST_HPP
23#define __SLIST_HPP
24
25template<class T>
26class slist {
27public:
28  T *node;
29  slist<T> *prev, *next;
30
31  slist(T *anode = NULL, slist<T> *aprev =NULL)
32   : node(anode), prev(aprev), next(aprev ? aprev->next : NULL)
33   { if (prev) prev->next=this;
34     if (next) next->prev=this; }
35
36
37  ~slist()
38  { if (prev) prev->next=next;
39    if (next) next->prev=prev;
40  }
41};
42
43#include <vector>
44#include "c2py.hpp"
45
46class TCharBuffer {
47public:
48  char *buf, *bufe;
49  char *bufptr;
50
51  TCharBuffer(const int &size)
52  {
53    if (size) {
54      buf = bufptr = (char *)malloc(size);
55      bufe = buf + size;
56    }
57    else
58      buf = bufptr = bufe = NULL;
59  }
60
61
62  TCharBuffer(char *abuf)
63  : buf(abuf),
64    bufe(NULL),
65    bufptr(abuf)
66  {}
67
68
69  ~TCharBuffer()
70  {
71    if (buf && bufe) // if there's no bufe, we don't own the buffer
72      free(buf);
73  }
74
75  inline Py_ssize_t length()
76  { return bufptr - buf; }
77
78  inline void ensure(const Py_ssize_t &size)
79  { 
80    if (!buf) {
81       Py_ssize_t rsize = size > 1024 ? size : 1024;
82       buf = bufptr = (char *)malloc(rsize);
83       bufe = buf + rsize;
84    }
85
86    else if (bufe - bufptr < size) {
87       int tsize = bufe - buf;
88       tsize = tsize < 65536 ? tsize << 1 : tsize + 65536;
89       const int tpos = bufptr - buf;
90       buf = (char *)realloc(buf, tsize);
91       bufe = buf + tsize;
92       bufptr = buf + tpos;
93    }
94  }
95
96  inline void writeChar(const char &c)
97  {
98    ensure(sizeof(char));
99    *bufptr++ = c;
100  }
101
102  inline void writeShort(const unsigned short &c)
103  {
104    ensure(sizeof(unsigned short));
105    memcpy((void *) bufptr, (void *) &c, sizeof(unsigned short));
106    bufptr += sizeof(unsigned short);
107  }
108
109  inline void writeInt(const int &c)
110  {
111    ensure(sizeof(int));
112    memcpy((void *) bufptr, (void *) &c, sizeof(int));
113    bufptr += sizeof(int);
114  }
115
116  inline void writeLong(const long &c)
117  {
118    ensure(sizeof(long));
119    memcpy((void *) bufptr, (void *) &c, sizeof(long));
120    bufptr += sizeof(long);
121  }
122
123  inline void writeFloat(const float &c)
124  {
125    ensure(sizeof(float));
126    memcpy((void *) bufptr, (void *) &c, sizeof(float));
127    bufptr += sizeof(float);
128  }
129
130  inline void writeDouble(const double &c)
131  {
132    ensure(sizeof(double));
133    memcpy((void *) bufptr, (void *) &c, sizeof(float));
134    bufptr += sizeof(double);
135  }
136
137  inline void writeIntVector(const vector<int> &v)
138  {
139    int size = v.size();
140    ensure((size + 1) * sizeof(int));
141
142    memcpy((void *) bufptr, (void *)&size, sizeof(int));
143    bufptr += sizeof(int);
144    if (size > 0)
145    {
146        // This is legal as &v[0] is guaranteed to point to a
147        // contiguous memory block
148        memcpy((void *) bufptr, (void *) &v[0], size * sizeof(int));
149        bufptr += sizeof(int) * size;
150    }
151  }
152
153  inline void writeFloatVector(const vector<float> &v)
154  {
155    int size = v.size();
156    ensure(sizeof(int) + size * sizeof(float));
157
158    memcpy((void *) bufptr, (void *)&size, sizeof(int));
159    bufptr += sizeof(int);
160    if (size > 0)
161    {
162        // This is legal as &v[0] is guaranteed to point to a
163        // contiguous memory block
164        memcpy((void *) bufptr, (void *) &v[0], size * sizeof(float));
165        bufptr += sizeof(float) * size;
166    }
167  }
168
169  inline void writeBuf(const void *abuf, size_t size)
170  {
171    ensure(size);
172    memcpy(bufptr, abuf, size);
173    bufptr += size;
174  }
175
176  inline char readChar()
177  { 
178    return *bufptr++;
179  }
180
181  inline unsigned short readShort()
182  {
183    unsigned short &res = (unsigned short &)*bufptr;
184    bufptr += sizeof(short);
185    return res;
186  }
187
188  inline int readInt()
189  { 
190    int &res = (int &)*bufptr;
191    bufptr += sizeof(int);
192    return res;
193  }
194
195  inline long readLong()
196  { 
197    long &res = (long &)*bufptr;
198    bufptr += sizeof(long);
199    return res;
200  }
201
202  inline float readFloat()
203  {
204    float &res = (float &)*bufptr;
205    bufptr += sizeof(float);
206    return res;
207  }
208
209  inline double readDouble()
210  {
211    double &res = (double &)*bufptr;
212    bufptr += sizeof(double);
213    return res;
214  }
215
216  inline void readIntVector(vector<int> &v)
217  {
218    int *&buff = (int *&)bufptr;
219    int size = *buff++;
220    v.resize(size);
221
222    for(vector<int>::iterator vi = v.begin(); size--; *vi++ = *buff++);
223  }
224
225  inline void readFloatVector(vector<float> &v)
226  {
227    int size = readInt();
228    v.resize(size);
229
230    float *&buff = (float *&)bufptr;
231    for(vector<float>::iterator vi = v.begin(); size--; *vi++ = *buff++);
232  }
233
234  inline void readBuf(void *abuf, size_t size)
235  {
236    memcpy(abuf, bufptr, size);
237    bufptr += size;
238  }
239};
240
241
242#endif
Note: See TracBrowser for help on using the repository browser.