#pragma once
#include <memory>
#include <thread>
#include <mutex>
#include <queue>
#include <boost/utility.hpp>

namespace Core {

   template<class T>
   class LockedQueue
   {
   public:
      LockedQueue();
      ~LockedQueue();

      T pop();

      //we can pass this in by reference, instead of copying
      void push(const T object);

      //we can pass this in by reference
      //this will push it onto the queue, and swap the object
      // with a default-constructed T at the same time.
      void push_swap(T& object);
      void push_reset(T& object);


      std::size_t size();


   protected:
      std::queue<T>	m_queue;
      std::mutex		m_mutex;

   };

   template <class T>
   LockedQueue<T>::LockedQueue() 
   {

   }

   template <class T>
   std::size_t LockedQueue<T>::size() 
   {
      std::lock_guard<std::mutex> lock( m_mutex);
      return  m_queue.size();
   }


   template <class T>
   LockedQueue<T>::~LockedQueue() 
   {


   }


   template <class T>
   T LockedQueue<T>::pop() 
   {
      std::lock_guard<std::mutex> lock( m_mutex);

      if( m_queue.empty())
      {
         return T();
      }

      T result =  m_queue.front();

      m_queue.pop();

      return result;
   }

   template <class T>
   void LockedQueue<T>::push(const T object) 
   {
      std::lock_guard<std::mutex> lock( m_mutex);
      m_queue.push(object);
   }

   template <class T>
   void LockedQueue<T>::push_swap(T& object) 
   {
      std::lock_guard<std::mutex> lock( m_mutex);

      m_queue.push(object);

      T default_ctored_object = T();
      //this is a special swap that will do a legit naive swap normally,
      // except if there exists a function called T::swap(), which is
      // specialized and possibly faster.
      boost::swap(object, default_ctored_object);



      //default_ctored_object is now the value of object, and it will go out
      // of scope here. In the case that T is a shared_ptr of some kind,
      // this will allow that the object on the queue is the *last* shared_ptr
      // in existance by the time this function returns.

   }

   template <class T>
   void LockedQueue<T>::push_reset(T& object) 
   {
      std::lock_guard<std::mutex> lock( m_mutex);

      m_queue.push(object);

      T default_ctored_object = T();

      object.reset();

      //default_ctored_object is now the value of object, and it will go out
      // of scope here. In the case that T is a shared_ptr of some kind,
      // this will allow that the object on the queue is the *last* shared_ptr
      // in existance by the time this function returns.

   }

}