source: orange/source/orange/slist.hpp @ 6531:57bdc92cd8e9

Revision 6531:57bdc92cd8e9, 4.7 KB checked in by janezd <janez.demsar@…>, 4 years ago (diff)
  • changed licenses to GPL 3.0
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    (unsigned short &)*bufptr = c;
106    bufptr += sizeof(unsigned short);
107  }
108
109  inline void writeInt(const int &c)
110  {
111    ensure(sizeof(int));
112    (int &)*bufptr = c;
113    bufptr += sizeof(int);
114  }
115
116  inline void writeLong(const long &c)
117  {
118    ensure(sizeof(long));
119    (long &)*bufptr = c;
120    bufptr += sizeof(long);
121  }
122
123  inline void writeFloat(const float &c)
124  {
125    ensure(sizeof(float));
126    (float &)*bufptr = c;
127    bufptr += sizeof(float);
128  }
129
130  inline void writeDouble(const double &c)
131  {
132    ensure(sizeof(double));
133    (double &)*bufptr = c;
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    int *&buff = (int *&)bufptr;
143    *buff++ = size;
144    for(vector<int>::const_iterator vi = v.begin(); size--; *buff++ = *vi++);
145  }
146
147  inline void writeFloatVector(const vector<float> &v)
148  {
149    int size = v.size();
150    ensure(sizeof(int) + size * sizeof(float));
151
152    (int &)*bufptr = size;
153    bufptr += sizeof(int);
154
155    float *&buff = (float *&)bufptr;
156    for(vector<float>::const_iterator vi = v.begin(); size--; *buff++ = *vi++);
157  }
158
159
160  inline void writeBuf(const void *abuf, size_t size)
161  {
162    ensure(size);
163    memcpy(bufptr, abuf, size);
164    bufptr += size;
165  }
166
167
168  inline char readChar()
169  { 
170    return *bufptr++;
171  }
172
173  inline unsigned short readShort()
174  {
175    unsigned short &res = (unsigned short &)*bufptr;
176    bufptr += sizeof(short);
177    return res;
178  }
179
180  inline int readInt()
181  { 
182    int &res = (int &)*bufptr;
183    bufptr += sizeof(int);
184    return res;
185  }
186
187  inline long readLong()
188  { 
189    long &res = (long &)*bufptr;
190    bufptr += sizeof(long);
191    return res;
192  }
193
194  inline float readFloat()
195  {
196    float &res = (float &)*bufptr;
197    bufptr += sizeof(float);
198    return res;
199  }
200
201  inline double readDouble()
202  {
203    double &res = (double &)*bufptr;
204    bufptr += sizeof(double);
205    return res;
206  }
207
208  inline void readIntVector(vector<int> &v)
209  {
210    int *&buff = (int *&)bufptr;
211    int size = *buff++;
212    v.resize(size);
213
214    for(vector<int>::iterator vi = v.begin(); size--; *vi++ = *buff++);
215  }
216
217  inline void readFloatVector(vector<float> &v)
218  {
219    int size = readInt();
220    v.resize(size);
221
222    float *&buff = (float *&)bufptr;
223    for(vector<float>::iterator vi = v.begin(); size--; *vi++ = *buff++);
224  }
225
226  inline void readBuf(void *abuf, size_t size)
227  {
228    memcpy(abuf, bufptr, size);
229    bufptr += size;
230  }
231};
232
233
234#endif
Note: See TracBrowser for help on using the repository browser.