query.hpp

Go to the documentation of this file.

#ifndef ASQLQUERY_HPP
#define ASQLQUERY_HPP

#include <boost/static_assert.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/utility/enable_if.hpp>

#include <asql/data.hpp>
#include <asql/exception.hpp>

namespace ASql
{

   class QueryPar
   {
   private:
      struct SharedData
      {
         enum Flags { FLAG_SINGLE_PARAMETERS=1, FLAG_SINGLE_RESULTS=1<<1 };


         SharedData(): m_parameters(0), m_results(0), m_insertId(0), m_rows(0), m_cancel(false), m_flags(0) {}
         ~SharedData()
         {
            delete m_rows;
            delete m_insertId;
            destroyResults();
            destroyParameters();
         }


         void* m_parameters;


         void* m_results;

         unsigned long long int* m_insertId;
         unsigned long long int* m_rows;

         Error m_error;

         boost::function<void()> m_callback;

         boost::mutex m_callbackMutex;

         bool m_cancel;


         unsigned char m_flags;


         void destroyResults()
         {
            if(m_flags&FLAG_SINGLE_RESULTS)
               delete static_cast<Data::Set*>(m_results);
            else
               delete static_cast<Data::SetContainer*>(m_results);
            m_results = 0;
         }


         void destroyParameters()
         {
            if(m_flags&FLAG_SINGLE_PARAMETERS)
               delete static_cast<Data::Set*>(m_parameters);
            else
               delete static_cast<Data::SetContainer*>(m_parameters);
            m_parameters = 0;
         }
      };

      boost::shared_ptr<SharedData> m_sharedData;


      unsigned char m_flags;

      enum Flags { FLAG_ORIGINAL=1, FLAG_KEEPALIVE=1<<1 };

      void callback()
      {
         boost::lock_guard<boost::mutex> lock(m_sharedData->m_callbackMutex);
         if(!m_sharedData->m_callback.empty())
            m_sharedData->m_callback();
      }

      void clearResults() { m_sharedData->destroyResults(); } 
      void clearParameters() { m_sharedData->destroyParameters(); } 

      template<class T> friend class ConnectionPar;

   protected:

      QueryPar(bool singleParameters, bool singleResults): m_sharedData(new SharedData), m_flags(FLAG_ORIGINAL)
      {
         if(singleParameters)
            m_sharedData->m_flags|=SharedData::FLAG_SINGLE_PARAMETERS;
         if(singleResults)
            m_sharedData->m_flags|=SharedData::FLAG_SINGLE_RESULTS;
      }


      void setResults(void* results) { m_sharedData->destroyResults(); m_sharedData->m_results=results; }


      void setParameters(void* parameters) { m_sharedData->destroyParameters(); m_sharedData->m_parameters=parameters; }


      void* relinquishResults() { void* data = m_sharedData->m_results; m_sharedData->m_results=0; return data; }


      void* relinquishParameters() { void* data = m_sharedData->m_parameters; m_sharedData->m_parameters=0; return data; }


      void* results() { return m_sharedData->m_results; }


      const void* results() const { return m_sharedData->m_results; }


      void* parameters() { return m_sharedData->m_parameters; }


      const void* parameters() const { return m_sharedData->m_parameters; }

   public:

      QueryPar(const QueryPar& x): m_sharedData(x.m_sharedData), m_flags(0) {}

      ~QueryPar()
      {
         // This might seem like we aren't checking for keepalive, but we are
         if(m_flags == FLAG_ORIGINAL)
            cancel();
      }

      unsigned int insertId() const { return m_sharedData->m_insertId?*(m_sharedData->m_insertId):0; }


      unsigned int rows() const { return m_sharedData->m_rows?*(m_sharedData->m_rows):0; }

      bool busy() const { return m_sharedData.use_count() != 1; }


      Error error() const { return m_sharedData->m_error; }


      void setCallback(boost::function<void()> callback=boost::function<void()>())
      {
         boost::lock_guard<boost::mutex> lock(m_sharedData->m_callbackMutex);
         m_sharedData->m_callback = callback;
      }

      bool isCallback() { return !m_sharedData->m_callback.empty(); }

      boost::function<void()> getCallback()
      {
         return m_sharedData->m_callback;
      }


      void keepAlive(bool x) { if(x) m_flags|=FLAG_KEEPALIVE; else m_flags&=~FLAG_KEEPALIVE; }


      void cancel() { m_sharedData->m_cancel = true; }

      void enableRows()
      {
         if(!m_sharedData->m_rows)
            m_sharedData->m_rows = new unsigned long long;
      }

      void enableInsertId()
      {
         if(!m_sharedData->m_insertId)
            m_sharedData->m_insertId = new unsigned long long;
      }

      void reset()
      {
         unsigned char flags = m_sharedData->m_flags;
         m_sharedData.reset(new SharedData);
         m_sharedData->m_flags = flags;

         m_flags=FLAG_ORIGINAL;
         keepAlive(false);
      }
   };


   template<class Parameters = void, class Results = void, class ParametersParent = void, class ResultsParent = void>
   struct Query: public QueryPar
   {
      // This default template should never be instanced
   private:
      Query() {}
      Query(const Query& x) {}
   };

   template<> struct Query<void, void, void, void>: public QueryPar
   {
      Query(): QueryPar(true, false) {}
      Query(const Query& x): QueryPar(x) {}
   };


   template<class Parameters, class Results>
   struct Query<Parameters, Results, typename boost::enable_if<boost::is_base_of<Data::Set, Parameters> >::type,  typename boost::enable_if<boost::is_base_of<Data::Set, Results> >::type>: public QueryPar
   {
      Query(): QueryPar(true, true) {}
      Query(const Query& x): QueryPar(x) {}

      static Query& staticRebuild(QueryPar& x) { return static_cast<Query&>(x); }

      static Query& dynamicRebuild(QueryPar& x) { return dynamic_cast<Query&>(x); }


      Parameters& createParameters() { Parameters* parameters=new Parameters; QueryPar::setParameters(parameters); return *parameters; }


      void setParameters(Parameters* parameters) { QueryPar::setParameters(parameters); }

      Parameters* parameters() { return static_cast<Parameters*>((ASql::Data::Set*)(QueryPar::parameters())); }

      const Parameters* parameters() const { return static_cast<const Parameters*>((const ASql::Data::Set*)(QueryPar::parameters())); }


      Parameters* relinquishParameters() {  return static_cast<Parameters*>((ASql::Data::Set*)(QueryPar::relinquishParameters())); }


      Results& createResults() { Results* results=new Results; QueryPar::setResults(results); return *results; }


      void setResults(Results* results) { QueryPar::setResults(results); }

      Results* results() { return static_cast<Results*>((ASql::Data::Set*)(QueryPar::results())); }

      const Results* results() const { return static_cast<const Results*>((const ASql::Data::Set*)(QueryPar::results())); }


      Results* relinquishResults() { return static_cast<Results*>((ASql::Data::Set*)(QueryPar::relinquishResults())); }
   };


   template<class Parameters, class Results>
   struct Query<Parameters, Results, typename boost::enable_if<boost::is_base_of<Data::Set, Parameters> >::type,  typename boost::enable_if<boost::is_base_of<Data::SetContainer, Results> >::type>: public QueryPar
   {
      Query(): QueryPar(true, false) {}
      Query(const Query& x): QueryPar(x) {}

      static Query& staticRebuild(QueryPar& x) { return static_cast<Query&>(x); }

      static Query& dynamicRebuild(QueryPar& x) { return dynamic_cast<Query&>(x); }


      Parameters& createParameters() { Parameters* parameters=new Parameters; QueryPar::setParameters(parameters); return *parameters; }


      void setParameters(Parameters* parameters) { QueryPar::setParameters(parameters); }

      Parameters* parameters() { return static_cast<Parameters*>((ASql::Data::Set*)(QueryPar::parameters())); }

      const Parameters* parameters() const { return static_cast<const Parameters*>((const ASql::Data::Set*)(QueryPar::parameters())); }


      Parameters* relinquishParameters() {  return static_cast<Parameters*>((ASql::Data::Set*)(QueryPar::relinquishParameters())); }


      Results& createResults() { Results* results=new Results; QueryPar::setResults(results); return *results; }


      void setResults(Results* results) { QueryPar::setResults(results); }

      Results* results() { return static_cast<Results*>((ASql::Data::SetContainer*)(QueryPar::results())); }

      const Results* results() const { return static_cast<const Results*>((const ASql::Data::SetContainer*)(QueryPar::results())); }


      Results* relinquishResults() { return static_cast<Results*>((ASql::Data::SetContainer*)(QueryPar::relinquishResults())); }
   };


   template<class Results>
   struct Query<void, Results, void,  typename boost::enable_if<boost::is_base_of<Data::Set, Results> >::type>: public QueryPar
   {
      Query(): QueryPar(true, true) {}
      Query(const Query& x): QueryPar(x) {}

      static Query& staticRebuild(QueryPar& x) { return static_cast<Query&>(x); }

      static Query& dynamicRebuild(QueryPar& x) { return dynamic_cast<Query&>(x); }


      Results& createResults() { Results* results=new Results; QueryPar::setResults(results); return *results; }


      void setResults(Results* results) { QueryPar::setResults(results); }

      Results* results() { return static_cast<Results*>((ASql::Data::Set*)(QueryPar::results())); }

      const Results* results() const { return static_cast<const Results*>((const ASql::Data::Set*)(QueryPar::results())); }


      Results* relinquishResults() { return static_cast<Results*>((ASql::Data::Set*)(QueryPar::relinquishResults())); }
   };


   template<class Results>
   struct Query<void, Results, void,  typename boost::enable_if<boost::is_base_of<Data::SetContainer, Results> >::type>: public QueryPar
   {
      Query(): QueryPar(true, false) {}
      Query(const Query& x): QueryPar(x) {}

      static Query& staticRebuild(QueryPar& x) { return static_cast<Query&>(x); }

      static Query& dynamicRebuild(QueryPar& x) { return dynamic_cast<Query&>(x); }


      Results& createResults() { Results* results=new Results; QueryPar::setResults(results); return *results; }


      void setResults(Results* results) { QueryPar::setResults(results); }

      Results* results() { return static_cast<Results*>((ASql::Data::SetContainer*)(QueryPar::results())); }

      const Results* results() const { return static_cast<const Results*>((const ASql::Data::SetContainer*)(QueryPar::results())); }


      Results* relinquishResults() { return static_cast<Results*>((ASql::Data::SetContainer*)(QueryPar::relinquishResults())); }
   };


   template<class Parameters>
   struct Query<Parameters, void, typename boost::enable_if<boost::is_base_of<Data::Set, Parameters> >::type, void>: public QueryPar
   {
      Query(): QueryPar(true, false) {}
      Query(const Query& x): QueryPar(x) {}

      static Query& staticRebuild(QueryPar& x) { return static_cast<Query&>(x); }

      static Query& dynamicRebuild(QueryPar& x) { return dynamic_cast<Query&>(x); }


      Parameters& createParameters() { Parameters* parameters=new Parameters; QueryPar::setParameters(parameters); return *parameters; }

      const Parameters* parameters() const { return static_cast<const Parameters*>((const ASql::Data::Set*)(QueryPar::parameters())); }


      void setParameters(Parameters* parameters) { QueryPar::setParameters(parameters); }

      Parameters* parameters() { return static_cast<Parameters*>((ASql::Data::Set*)(QueryPar::parameters()));; }


      Parameters* relinquishParameters() {  return static_cast<Parameters*>((ASql::Data::Set*)(QueryPar::relinquishParameters())); }
   };


   template<class Parameters>
   struct Query<Parameters, void, typename boost::enable_if<boost::is_base_of<Data::SetContainer, Parameters> >::type, void>: public QueryPar
   {
      Query(): QueryPar(false, false) {}
      Query(const Query& x): QueryPar(x) {}

      static Query& staticRebuild(QueryPar& x) { return static_cast<Query&>(x); }

      static Query& dynamicRebuild(QueryPar& x) { return dynamic_cast<Query&>(x); }


      Parameters& createParameters() { Parameters* parameters=new Parameters; QueryPar::setParameters(parameters); return *parameters; }


      void setParameters(Parameters* parameters) { QueryPar::setParameters(parameters); }

      Parameters* parameters() { return static_cast<Parameters*>((ASql::Data::SetContainer*)(QueryPar::parameters())); }

      const Parameters* parameters() const { return static_cast<const Parameters*>((const ASql::Data::SetContainer*)(QueryPar::parameters())); }


      Parameters* relinquishParameters() {  return static_cast<Parameters*>((ASql::Data::SetContainer*)(QueryPar::relinquishParameters())); }
   };
}

#endif