Panda3D

cycleDataStageWriter.I

00001 // Filename: cycleDataStageWriter.I
00002 // Created by:  drose (06Feb06)
00003 //
00004 ////////////////////////////////////////////////////////////////////
00005 //
00006 // PANDA 3D SOFTWARE
00007 // Copyright (c) Carnegie Mellon University.  All rights reserved.
00008 //
00009 // All use of this software is subject to the terms of the revised BSD
00010 // license.  You should have received a copy of this license along
00011 // with this source code in a file named "LICENSE."
00012 //
00013 ////////////////////////////////////////////////////////////////////
00014 
00015 #ifndef CPPPARSER
00016 
00017 #ifdef DO_PIPELINING
00018 // This is the implementation for full support of pipelining (as well
00019 // as the sanity-check only implementation).
00020 
00021 ////////////////////////////////////////////////////////////////////
00022 //     Function: CycleDataStageWriter::Constructor (full)
00023 //       Access: Public
00024 //  Description:
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 //     Function: CycleDataStageWriter::Constructor (full)
00040 //       Access: Public
00041 //  Description:
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 //     Function: CycleDataStageWriter::Copy Constructor (full)
00057 //       Access: Public
00058 //  Description:
00059 ////////////////////////////////////////////////////////////////////
00060 template<class CycleDataType>
00061 INLINE CycleDataStageWriter<CycleDataType>::
00062 CycleDataStageWriter(const CycleDataStageWriter<CycleDataType> &copy) :
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 //     Function: CycleDataStageWriter::Copy Assignment (full)
00074 //       Access: Public
00075 //  Description:
00076 ////////////////////////////////////////////////////////////////////
00077 template<class CycleDataType>
00078 INLINE void CycleDataStageWriter<CycleDataType>::
00079 operator = (const CycleDataStageWriter<CycleDataType> &copy) {
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 //     Function: CycleDataStageWriter::Constructor (full)
00093 //       Access: Public
00094 //  Description: This flavor of the constructor elevates the pointer
00095 //               from the CycleDataLockedStageReader from a read to a write
00096 //               pointer (and invalidates the reader).
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 //     Function: CycleDataStageWriter::Constructor (full)
00112 //       Access: Public
00113 //  Description: This flavor of the constructor elevates the pointer
00114 //               from the CycleDataLockedStageReader from a read to a write
00115 //               pointer (and invalidates the reader).
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 //     Function: CycleDataStageWriter::Destructor (full)
00132 //       Access: Public
00133 //  Description:
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 //     Function: CycleDataStageWriter::operator -> (full)
00145 //       Access: Public
00146 //  Description: This provides an indirect member access to the actual
00147 //               CycleData data.
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 //     Function: CycleDataStageWriter::operator -> (full)
00158 //       Access: Public
00159 //  Description: This provides an indirect member access to the actual
00160 //               CycleData data.
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 //     Function: CycleDataStageWriter::Typecast pointer (full)
00171 //       Access: Public
00172 //  Description: This allows the CycleDataStageWriter to be passed to any
00173 //               function that expects a CycleDataType pointer.
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 //     Function: CycleDataStageWriter::get_current_thread (full)
00184 //       Access: Public
00185 //  Description: Returns the Thread pointer of the currently-executing
00186 //               thread, as passed to the constructor of this object.
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 // This is the trivial, do-nothing implementation.
00196 
00197 ////////////////////////////////////////////////////////////////////
00198 //     Function: CycleDataStageWriter::Constructor (trivial)
00199 //       Access: Public
00200 //  Description:
00201 ////////////////////////////////////////////////////////////////////
00202 template<class CycleDataType>
00203 INLINE CycleDataStageWriter<CycleDataType>::
00204 CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int, Thread *) {
00205   _pointer = cycler.cheat();
00206 }
00207 
00208 ////////////////////////////////////////////////////////////////////
00209 //     Function: CycleDataStageWriter::Constructor (trivial)
00210 //       Access: Public
00211 //  Description:
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 //     Function: CycleDataStageWriter::Copy Constructor (trivial)
00221 //       Access: Public
00222 //  Description:
00223 ////////////////////////////////////////////////////////////////////
00224 template<class CycleDataType>
00225 INLINE CycleDataStageWriter<CycleDataType>::
00226 CycleDataStageWriter(const CycleDataStageWriter<CycleDataType> &copy) :
00227   _pointer(copy._pointer)
00228 {
00229 }
00230 
00231 ////////////////////////////////////////////////////////////////////
00232 //     Function: CycleDataStageWriter::Copy Assignment (trivial)
00233 //       Access: Public
00234 //  Description:
00235 ////////////////////////////////////////////////////////////////////
00236 template<class CycleDataType>
00237 INLINE void CycleDataStageWriter<CycleDataType>::
00238 operator = (const CycleDataStageWriter<CycleDataType> &copy) {
00239   _pointer = copy._pointer;
00240 }
00241 
00242 ////////////////////////////////////////////////////////////////////
00243 //     Function: CycleDataStageWriter::Constructor (trivial)
00244 //       Access: Public
00245 //  Description: This flavor of the constructor elevates the pointer
00246 //               from the CycleDataLockedStageReader from a read to a write
00247 //               pointer (and invalidates the reader).
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 //     Function: CycleDataStageWriter::Constructor (trivial)
00259 //       Access: Public
00260 //  Description: This flavor of the constructor elevates the pointer
00261 //               from the CycleDataLockedStageReader from a read to a write
00262 //               pointer (and invalidates the reader).
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 //     Function: CycleDataStageWriter::Destructor (trivial)
00275 //       Access: Public
00276 //  Description:
00277 ////////////////////////////////////////////////////////////////////
00278 template<class CycleDataType>
00279 INLINE CycleDataStageWriter<CycleDataType>::
00280 ~CycleDataStageWriter() {
00281 }
00282 
00283 ////////////////////////////////////////////////////////////////////
00284 //     Function: CycleDataStageWriter::operator -> (trivial)
00285 //       Access: Public
00286 //  Description: This provides an indirect member access to the actual
00287 //               CycleData data.
00288 ////////////////////////////////////////////////////////////////////
00289 template<class CycleDataType>
00290 INLINE CycleDataType *CycleDataStageWriter<CycleDataType>::
00291 operator -> () {
00292   return _pointer;
00293 }
00294 
00295 ////////////////////////////////////////////////////////////////////
00296 //     Function: CycleDataStageWriter::operator -> (trivial)
00297 //       Access: Public
00298 //  Description: This provides an indirect member access to the actual
00299 //               CycleData data.
00300 ////////////////////////////////////////////////////////////////////
00301 template<class CycleDataType>
00302 INLINE const CycleDataType *CycleDataStageWriter<CycleDataType>::
00303 operator -> () const {
00304   return _pointer;
00305 }
00306 
00307 ////////////////////////////////////////////////////////////////////
00308 //     Function: CycleDataStageWriter::Typecast pointer (trivial)
00309 //       Access: Public
00310 //  Description: This allows the CycleDataStageWriter to be passed to any
00311 //               function that expects a CycleDataType pointer.
00312 ////////////////////////////////////////////////////////////////////
00313 template<class CycleDataType>
00314 INLINE CycleDataStageWriter<CycleDataType>::
00315 operator CycleDataType * () {
00316   return _pointer;
00317 }
00318 
00319 ////////////////////////////////////////////////////////////////////
00320 //     Function: CycleDataStageWriter::get_current_thread (trivial)
00321 //       Access: Public
00322 //  Description: Returns the Thread pointer of the currently-executing
00323 //               thread, as passed to the constructor of this object.
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
 All Classes Functions Variables Enumerations