Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #if !defined (octave_local_buffer_h)
00024 #define octave_local_buffer_h 1
00025
00026 #include <cstddef>
00027 #include "oct-cmplx.h"
00028
00029
00030
00031
00032 template <class T>
00033 class octave_local_buffer
00034 {
00035 public:
00036 octave_local_buffer (size_t size)
00037 : data (0)
00038 {
00039 if (size)
00040 data = new T[size];
00041 }
00042 ~octave_local_buffer (void) { delete [] data; }
00043 operator T *() const { return data; }
00044
00045 private:
00046 T *data;
00047
00048
00049 octave_local_buffer (const octave_local_buffer&);
00050 octave_local_buffer& operator = (const octave_local_buffer&);
00051 };
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 class octave_chunk_buffer
00066 {
00067 public:
00068
00069 OCTAVE_API octave_chunk_buffer (size_t size);
00070
00071 OCTAVE_API virtual ~octave_chunk_buffer (void);
00072
00073 char *data (void) const { return dat; }
00074
00075 private:
00076 static const size_t chunk_size;
00077
00078 static char *top, *chunk;
00079 static size_t left;
00080
00081 char *cnk;
00082 char *dat;
00083
00084
00085 octave_chunk_buffer (const octave_chunk_buffer&);
00086 octave_chunk_buffer& operator = (const octave_chunk_buffer&);
00087 };
00088
00089
00090
00091 #define SPECIALIZE_POD_BUFFER(TYPE) \
00092 template <> \
00093 class octave_local_buffer<TYPE> : private octave_chunk_buffer \
00094 { \
00095 public: \
00096 octave_local_buffer (size_t size) \
00097 : octave_chunk_buffer (size * sizeof (TYPE)) { } \
00098 \
00099 operator TYPE *() const \
00100 { \
00101 return reinterpret_cast<TYPE *> (this->data ()); \
00102 } \
00103 }
00104
00105 SPECIALIZE_POD_BUFFER (bool);
00106 SPECIALIZE_POD_BUFFER (char);
00107 SPECIALIZE_POD_BUFFER (unsigned short);
00108 SPECIALIZE_POD_BUFFER (short);
00109 SPECIALIZE_POD_BUFFER (int);
00110 SPECIALIZE_POD_BUFFER (unsigned int);
00111 SPECIALIZE_POD_BUFFER (long);
00112 SPECIALIZE_POD_BUFFER (unsigned long);
00113 SPECIALIZE_POD_BUFFER (float);
00114 SPECIALIZE_POD_BUFFER (double);
00115
00116 SPECIALIZE_POD_BUFFER (Complex);
00117 SPECIALIZE_POD_BUFFER (FloatComplex);
00118
00119
00120
00121 template <class T>
00122 class octave_local_buffer<T *> : private octave_chunk_buffer
00123 {
00124 public:
00125 octave_local_buffer (size_t size)
00126 : octave_chunk_buffer (size * sizeof (T *))
00127 { }
00128
00129 operator T **() const { return reinterpret_cast<T **> (this->data ()); }
00130 };
00131
00132 template <class T>
00133 class octave_local_buffer<const T *> : private octave_chunk_buffer
00134 {
00135 public:
00136 octave_local_buffer (size_t size)
00137 : octave_chunk_buffer (size * sizeof (const T *))
00138 { }
00139
00140 operator const T **() const
00141 {
00142 return reinterpret_cast<const T **> (this->data ());
00143 }
00144 };
00145
00146
00147
00148
00149
00150 #if 0 //defined (HAVE_DYNAMIC_AUTO_ARRAYS)
00151
00152
00153
00154 #define OCTAVE_LOCAL_BUFFER_MAX_STACK_SIZE 8192
00155
00156
00157
00158
00159
00160
00161 #define OCTAVE_LOCAL_BUFFER(T, buf, size) \
00162 const size_t _bufsize_ ## buf = size; \
00163 const bool _lbufaut_ ## buf = _bufsize_ ## buf * sizeof (T) \
00164 <= OCTAVE_LOCAL_BUFFER_MAX_STACK_SIZE; \
00165 T _bufaut_ ## buf [_lbufaut_ ## buf ? _bufsize_ ## buf : 0]; \
00166 octave_local_buffer<T> _bufheap_ ## buf (!_lbufaut_ ## buf ? _bufsize_ ## buf : 0); \
00167 T *buf = _lbufaut_ ## buf ? _bufaut_ ## buf : static_cast<T *> (_bufheap_ ## buf)
00168
00169 #else
00170
00171
00172
00173 #define OCTAVE_LOCAL_BUFFER(T, buf, size) \
00174 octave_local_buffer<T> _buffer_ ## buf (size); \
00175 T *buf = _buffer_ ## buf
00176
00177 #endif
00178
00179
00180
00181
00182 #define OCTAVE_LOCAL_BUFFER_INIT(T, buf, size, value) \
00183 OCTAVE_LOCAL_BUFFER(T, buf, size); \
00184 for (size_t _buf_iter = 0, _buf_size = size; \
00185 _buf_iter < _buf_size; _buf_iter++) buf[_buf_iter] = value
00186
00187 #endif
00188