Add move semantics to CDLockedReader/CDWriter

panda/src/pipeline/cycleDataLockedReader.I

@@ -61,6 +61,36 @@ operator = (const CycleDataLockedReader<CycleDataType> &copy) {
   _cycler->increment_read(_pointer);
 }
 
+#ifdef USE_MOVE_SEMANTICS
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE CycleDataLockedReader<CycleDataType>::
+CycleDataLockedReader(CycleDataLockedReader<CycleDataType> &&from) NOEXCEPT :
+  _cycler(from._cycler),
+  _current_thread(from._current_thread),
+  _pointer(from._pointer)
+{
+  from._pointer = NULL;
+}
+
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE void CycleDataLockedReader<CycleDataType>::
+operator = (CycleDataLockedReader<CycleDataType> &&from) NOEXCEPT {
+  nassertv(_pointer == (CycleDataType *)NULL);
+  nassertv(_current_thread == from._current_thread);
+
+  _cycler = from._cycler;
+  _pointer = from._pointer;
+
+  from._pointer = NULL;
+}
+#endif  // USE_MOVE_SEMANTICS
+
 /**
  *
  */

panda/src/pipeline/cycleDataLockedReader.h

@@ -47,6 +47,11 @@ public:
   INLINE CycleDataLockedReader(const CycleDataLockedReader<CycleDataType> &copy);
   INLINE void operator = (const CycleDataLockedReader<CycleDataType> &copy);
 
+#if defined(USE_MOVE_SEMANTICS) && defined(DO_PIPELINING)
+  INLINE CycleDataLockedReader(CycleDataLockedReader<CycleDataType> &&from) NOEXCEPT;
+  INLINE void operator = (CycleDataLockedReader<CycleDataType> &&from) NOEXCEPT;
+#endif
+
   INLINE ~CycleDataLockedReader();
 
   INLINE const CycleDataType *operator -> () const;

panda/src/pipeline/cycleDataLockedStageReader.I

@@ -64,6 +64,38 @@ operator = (const CycleDataLockedStageReader<CycleDataType> &copy) {
   _cycler->increment_read(_pointer);
 }
 
+#ifdef USE_MOVE_SEMANTICS
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE CycleDataLockedStageReader<CycleDataType>::
+CycleDataLockedStageReader(CycleDataLockedStageReader<CycleDataType> &&from) NOEXCEPT :
+  _cycler(from._cycler),
+  _current_thread(from._current_thread),
+  _pointer(from._pointer),
+  _stage(from._stage)
+{
+  from._pointer = NULL;
+}
+
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE void CycleDataLockedStageReader<CycleDataType>::
+operator = (CycleDataLockedStageReader<CycleDataType> &&from) NOEXCEPT {
+  nassertv(_pointer == (CycleDataType *)NULL);
+  nassertv(_current_thread == from._current_thread);
+
+  _cycler = from._cycler;
+  _pointer = from._pointer;
+  _stage = from._stage;
+
+  from._pointer = NULL;
+}
+#endif  // USE_MOVE_SEMANTICS
+
 /**
  *
  */

panda/src/pipeline/cycleDataLockedStageReader.h

@@ -34,6 +34,11 @@ public:
   INLINE CycleDataLockedStageReader(const CycleDataLockedStageReader<CycleDataType> &copy);
   INLINE void operator = (const CycleDataLockedStageReader<CycleDataType> &copy);
 
+#if defined(USE_MOVE_SEMANTICS) && defined(DO_PIPELINING)
+  INLINE CycleDataLockedStageReader(CycleDataLockedStageReader<CycleDataType> &&from) NOEXCEPT;
+  INLINE void operator = (CycleDataLockedStageReader<CycleDataType> &&from) NOEXCEPT;
+#endif
+
   INLINE ~CycleDataLockedStageReader();
 
   INLINE const CycleDataType *operator -> () const;

panda/src/pipeline/cycleDataStageWriter.I

@@ -114,6 +114,38 @@ CycleDataStageWriter(PipelineCycler<CycleDataType> &cycler, int stage,
                                                   force_to_0, _current_thread);
 }
 
+#ifdef USE_MOVE_SEMANTICS
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE CycleDataStageWriter<CycleDataType>::
+CycleDataStageWriter(CycleDataStageWriter<CycleDataType> &&from) NOEXCEPT :
+  _cycler(from._cycler),
+  _current_thread(from._current_thread),
+  _pointer(from._pointer),
+  _stage(from._stage)
+{
+  from._pointer = NULL;
+}
+
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE void CycleDataStageWriter<CycleDataType>::
+operator = (CycleDataStageWriter<CycleDataType> &&from) NOEXCEPT {
+  nassertv(_pointer == (CycleDataType *)NULL);
+  nassertv(_current_thread == from._current_thread);
+
+  _cycler = from._cycler;
+  _pointer = from._pointer;
+  _stage = from._stage;
+
+  from._pointer = NULL;
+}
+#endif  // USE_MOVE_SEMANTICS
+
 /**
  *
  */

panda/src/pipeline/cycleDataStageWriter.h

@@ -47,6 +47,11 @@ public:
                               CycleDataLockedStageReader<CycleDataType> &take_from,
                               bool force_to_0);
 
+#if defined(USE_MOVE_SEMANTICS) && defined(DO_PIPELINING)
+  INLINE CycleDataStageWriter(CycleDataStageWriter<CycleDataType> &&from) NOEXCEPT;
+  INLINE void operator = (CycleDataStageWriter<CycleDataType> &&from) NOEXCEPT;
+#endif
+
   INLINE ~CycleDataStageWriter();
 
   INLINE CycleDataType *operator -> ();

panda/src/pipeline/cycleDataWriter.I

@@ -122,7 +122,7 @@ template<class CycleDataType>
 INLINE CycleDataWriter<CycleDataType>::
 CycleDataWriter(PipelineCycler<CycleDataType> &cycler,
                 CycleDataLockedReader<CycleDataType> &take_from,
-        bool force_to_0) :
+                bool force_to_0) :
   _cycler(&cycler),
   _current_thread(take_from.get_current_thread())
 {
@@ -130,6 +130,36 @@ CycleDataWriter(PipelineCycler<CycleDataType> &cycler,
                                             force_to_0, _current_thread);
 }
 
+#ifdef USE_MOVE_SEMANTICS
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE CycleDataWriter<CycleDataType>::
+CycleDataWriter(CycleDataWriter<CycleDataType> &&from) NOEXCEPT :
+  _cycler(from._cycler),
+  _current_thread(from._current_thread),
+  _pointer(from._pointer)
+{
+  from._pointer = NULL;
+}
+
+/**
+ *
+ */
+template<class CycleDataType>
+INLINE void CycleDataWriter<CycleDataType>::
+operator = (CycleDataWriter<CycleDataType> &&from) NOEXCEPT {
+  nassertv(_pointer == (CycleDataType *)NULL);
+  nassertv(_current_thread == from._current_thread);
+
+  _cycler = from._cycler;
+  _pointer = from._pointer;
+
+  from._pointer = NULL;
+}
+#endif  // USE_MOVE_SEMANTICS
+
 /**
  *
  */

panda/src/pipeline/cycleDataWriter.h

@@ -49,6 +49,11 @@ public:
   INLINE CycleDataWriter(PipelineCycler<CycleDataType> &cycler, CycleDataLockedReader<CycleDataType> &take_from);
   INLINE CycleDataWriter(PipelineCycler<CycleDataType> &cycler, CycleDataLockedReader<CycleDataType> &take_from, bool force_to_0);
 
+#if defined(USE_MOVE_SEMANTICS) && defined(DO_PIPELINING)
+  INLINE CycleDataWriter(CycleDataWriter<CycleDataType> &&from) NOEXCEPT;
+  INLINE void operator = (CycleDataWriter<CycleDataType> &&from) NOEXCEPT;
+#endif
+
   INLINE ~CycleDataWriter();
 
   INLINE CycleDataType *operator -> ();