00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef CPPPARSER
00016
00017 #ifdef DO_PIPELINING
00018
00019
00020
00021
00022
00023
00024
00025
00026 template<class CycleDataType>
00027 INLINE CycleDataStageWriter<CycleDataType>::
00028 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage,
00029 Thread *current_thread) :
00030 _cycler(&cycler),
00031 _current_thread(current_thread),
00032 _stage(stage)
00033 {
00034 _pointer = _cycler->write_stage(_stage, _current_thread);
00035 nassertv(_pointer != (CycleDataType *)NULL);
00036 }
00037
00038
00039
00040
00041
00042
00043 template<class CycleDataType>
00044 INLINE CycleDataStageWriter<CycleDataType>::
00045 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage,
00046 bool force_to_0, Thread *current_thread) :
00047 _cycler(&cycler),
00048 _current_thread(current_thread),
00049 _stage(stage)
00050 {
00051 _pointer = _cycler->write_stage_upstream(_stage, force_to_0, _current_thread);
00052 nassertv(_pointer != (CycleDataType *)NULL);
00053 }
00054
00055
00056
00057
00058
00059
00060 template<class CycleDataType>
00061 INLINE CycleDataStageWriter<CycleDataType>::
00062 CycleDataStageWriter(const CycleDataStageWriter<CycleDataType> ©) :
00063 _cycler(copy._cycler),
00064 _current_thread(copy._current_thread),
00065 _pointer(copy._pointer),
00066 _stage(copy._stage)
00067 {
00068 nassertv(_pointer != (CycleDataType *)NULL);
00069 _cycler->increment_write(_pointer);
00070 }
00071
00072
00073
00074
00075
00076
00077 template<class CycleDataType>
00078 INLINE void CycleDataStageWriter<CycleDataType>::
00079 operator = (const CycleDataStageWriter<CycleDataType> ©) {
00080 nassertv(_pointer == (CycleDataType *)NULL);
00081 nassertv(_current_thread == copy._current_thread);
00082
00083 _cycler = copy._cycler;
00084 _pointer = copy._pointer;
00085 _stage = copy._stage;
00086
00087 nassertv(_pointer != (CycleDataType *)NULL);
00088 _cycler->increment_write(_pointer);
00089 }
00090
00091
00092
00093
00094
00095
00096
00097
00098 template<class CycleDataType>
00099 INLINE CycleDataStageWriter<CycleDataType>::
00100 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage,
00101 CycleDataLockedStageReader<CycleDataType> &take_from) :
00102 _cycler(&cycler),
00103 _current_thread(take_from.get_current_thread()),
00104 _stage(stage)
00105 {
00106 _pointer = _cycler->elevate_read_stage(_stage, take_from.take_pointer(),
00107 _current_thread);
00108 }
00109
00110
00111
00112
00113
00114
00115
00116
00117 template<class CycleDataType>
00118 INLINE CycleDataStageWriter<CycleDataType>::
00119 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage,
00120 CycleDataLockedStageReader<CycleDataType> &take_from,
00121 bool force_to_0) :
00122 _cycler(&cycler),
00123 _current_thread(take_from.get_current_thread()),
00124 _stage(stage)
00125 {
00126 _pointer = _cycler->elevate_read_stage_upstream(_stage, take_from.take_pointer(),
00127 force_to_0, _current_thread);
00128 }
00129
00130
00131
00132
00133
00134
00135 template<class CycleDataType>
00136 INLINE CycleDataStageWriter<CycleDataType>::
00137 ~CycleDataStageWriter() {
00138 if (_pointer != (CycleDataType *)NULL) {
00139 _cycler->release_write_stage(_stage, _pointer);
00140 }
00141 }
00142
00143
00144
00145
00146
00147
00148
00149 template<class CycleDataType>
00150 INLINE CycleDataType *CycleDataStageWriter<CycleDataType>::
00151 operator -> () {
00152 nassertr(_pointer != (CycleDataType *)NULL, _cycler->cheat());
00153 return _pointer;
00154 }
00155
00156
00157
00158
00159
00160
00161
00162 template<class CycleDataType>
00163 INLINE const CycleDataType *CycleDataStageWriter<CycleDataType>::
00164 operator -> () const {
00165 nassertr(_pointer != (CycleDataType *)NULL, _cycler->cheat());
00166 return _pointer;
00167 }
00168
00169
00170
00171
00172
00173
00174
00175 template<class CycleDataType>
00176 INLINE CycleDataStageWriter<CycleDataType>::
00177 operator CycleDataType * () {
00178 nassertr(_pointer != (CycleDataType *)NULL, _cycler->cheat());
00179 return _pointer;
00180 }
00181
00182
00183
00184
00185
00186
00187
00188 template<class CycleDataType>
00189 INLINE Thread *CycleDataStageWriter<CycleDataType>::
00190 get_current_thread() const {
00191 return _current_thread;
00192 }
00193
00194 #else // !DO_PIPELINING
00195
00196
00197
00198
00199
00200
00201
00202 template<class CycleDataType>
00203 INLINE CycleDataStageWriter<CycleDataType>::
00204 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int, Thread *) {
00205 _pointer = cycler.cheat();
00206 }
00207
00208
00209
00210
00211
00212
00213 template<class CycleDataType>
00214 INLINE CycleDataStageWriter<CycleDataType>::
00215 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int, bool, Thread *) {
00216 _pointer = cycler.cheat();
00217 }
00218
00219
00220
00221
00222
00223
00224 template<class CycleDataType>
00225 INLINE CycleDataStageWriter<CycleDataType>::
00226 CycleDataStageWriter(const CycleDataStageWriter<CycleDataType> ©) :
00227 _pointer(copy._pointer)
00228 {
00229 }
00230
00231
00232
00233
00234
00235
00236 template<class CycleDataType>
00237 INLINE void CycleDataStageWriter<CycleDataType>::
00238 operator = (const CycleDataStageWriter<CycleDataType> ©) {
00239 _pointer = copy._pointer;
00240 }
00241
00242
00243
00244
00245
00246
00247
00248
00249 template<class CycleDataType>
00250 INLINE CycleDataStageWriter<CycleDataType>::
00251 CycleDataStageWriter(PipelineCycler<CycleDataType> &, int,
00252 CycleDataLockedStageReader<CycleDataType> &take_from) :
00253 _pointer((CycleDataType *)take_from.take_pointer())
00254 {
00255 }
00256
00257
00258
00259
00260
00261
00262
00263
00264 template<class CycleDataType>
00265 INLINE CycleDataStageWriter<CycleDataType>::
00266 CycleDataStageWriter(PipelineCycler<CycleDataType> &, int,
00267 CycleDataLockedStageReader<CycleDataType> &take_from,
00268 bool) :
00269 _pointer((CycleDataType *)take_from.take_pointer())
00270 {
00271 }
00272
00273
00274
00275
00276
00277
00278 template<class CycleDataType>
00279 INLINE CycleDataStageWriter<CycleDataType>::
00280 ~CycleDataStageWriter() {
00281 }
00282
00283
00284
00285
00286
00287
00288
00289 template<class CycleDataType>
00290 INLINE CycleDataType *CycleDataStageWriter<CycleDataType>::
00291 operator -> () {
00292 return _pointer;
00293 }
00294
00295
00296
00297
00298
00299
00300
00301 template<class CycleDataType>
00302 INLINE const CycleDataType *CycleDataStageWriter<CycleDataType>::
00303 operator -> () const {
00304 return _pointer;
00305 }
00306
00307
00308
00309
00310
00311
00312
00313 template<class CycleDataType>
00314 INLINE CycleDataStageWriter<CycleDataType>::
00315 operator CycleDataType * () {
00316 return _pointer;
00317 }
00318
00319
00320
00321
00322
00323
00324
00325 template<class CycleDataType>
00326 INLINE Thread *CycleDataStageWriter<CycleDataType>::
00327 get_current_thread() const {
00328 return Thread::get_current_thread();
00329 }
00330
00331 #endif // DO_PIPELINING
00332 #endif // CPPPARSER