data.hpp

Go to the documentation of this file.

#ifndef ASQLDATA_HPP
#define ASQLDATA_HPP

#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <ostream>
#include <vector>
#include <string>
#include <map>

#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp>
#define ASQL_BUILDSETLINE(r, data, i, elem) case i: return elem;

#define ASQL_BUILDSET(elements) \
   size_t numberOfSqlElements() const { return BOOST_PP_SEQ_SIZE(elements); } \
   ASql::Data::Index getSqlIndex(size_t index) const \
   { \
      switch(index) \
      { \
         BOOST_PP_SEQ_FOR_EACH_I(ASQL_BUILDSETLINE, 0, elements) \
         default: return ASql::Data::Index(); \
      } \
   }

namespace ASql
{
   namespace Data
   {

      enum Type { U_TINY=0,
                  U_SHORT,
                  U_INT,
                  U_BIGINT,
                  TINY,
                  SHORT,
                  INT,
                  BIGINT,
                  FLOAT,
                  DOUBLE,
                  TIME,
                  DATE,
                  DATETIME,
                  BLOB,
                  TEXT,
                  WTEXT,
                  CHAR,
                  BINARY,
                  BIT,     
                  U_TINY_N,
                  U_SHORT_N,
                  U_INT_N,
                  U_BIGINT_N,
                  TINY_N,
                  SHORT_N,
                  INT_N,
                  BIGINT_N,
                  FLOAT_N,
                  DOUBLE_N,
                  TIME_N,
                  DATE_N,
                  DATETIME_N,
                  BLOB_N,
                  TEXT_N,
                  WTEXT_N,
                  CHAR_N,
                  BINARY_N,
                  BIT_N,
                  NOTHING };
      

      struct NullablePar
      {
         NullablePar(bool _nullness): nullness(_nullness) { }
         bool nullness;

         virtual void* getVoid() =0;
      };
      
      template<class T> struct Nullable: public NullablePar
      {
         T object;
         void* getVoid() { return &object; }
         operator T() { return object; }
         operator const T() const { return object; }
         Nullable<T>& operator=(const T& x) { object=x; nullness=false; return *this; }
         Nullable(): NullablePar(true) {}
         Nullable(const T& x): NullablePar(false), object(x) { }
      };

      template<class T, int size> struct NullableArray: public NullablePar
      {
         T object[size];
         void* getVoid() { return object; }
         operator T*() { return object; }
         NullableArray(): NullablePar(false) {}
         NullableArray(const T& x): NullablePar(false), object(x) { }
      };

      template<class charT, class Traits, class T> inline std::basic_ostream<charT, Traits>& operator<<(std::basic_ostream<charT, Traits>& os, const Nullable<T>& x)
      {
         if(x.nullness)
            os << "NULL";
         else
            os << x.object;

         return os;
      }

      typedef unsigned char Utiny;
      typedef signed char Tiny;
      typedef unsigned short int Ushort;
      typedef short int Short;
      typedef unsigned int Uint;
      typedef int Int;
      typedef unsigned long long int Ubigint;
      typedef long long int Bigint;
      typedef float Float;
      typedef double Double;
      typedef boost::posix_time::time_duration Time;
      typedef boost::gregorian::date Date;
      typedef boost::posix_time::ptime Datetime;
      typedef std::string Text;
      typedef std::wstring Wtext;
      typedef bool Boolean;

      struct Blob
      {
         virtual size_t size() const =0;
         virtual void resize(const size_t size) =0;
         virtual char& operator[](const size_t index) =0;
      };
      struct VectorBlob: public Blob
      {
         std::vector<char>& m_data;
         VectorBlob(std::vector<char>& data): m_data(data) {}
         size_t size() const { return m_data.size(); }
         void resize(const size_t size) { m_data.resize(size); };
         char& operator[](const size_t index) { return m_data[index]; };
      };

      typedef Nullable<Utiny> UtinyN;
      typedef Nullable<Tiny> TinyN;
      typedef Nullable<Ushort> UshortN;
      typedef Nullable<Short> ShortN;
      typedef Nullable<Uint> UintN;
      typedef Nullable<Int> IntN;
      typedef Nullable<Ubigint> UbigintN;
      typedef Nullable<Bigint> BigintN;
      typedef Nullable<Float> FloatN;
      typedef Nullable<Double> DoubleN;
      typedef Nullable<Time> TimeN;
      typedef Nullable<Date> DateN;
      typedef Nullable<Datetime> DatetimeN;
      typedef Nullable<Text> TextN;
      typedef Nullable<Wtext> WtextN;
      typedef Nullable<Boolean> BooleanN;


      struct Index
      {
         Type type;
         void* data;
         size_t size;

         Index(const Utiny& x): type(U_TINY), data(const_cast<Utiny*>(&x)) { }
         Index(const Tiny& x): type(TINY), data(const_cast<Tiny*>(&x)) { }
         Index(const Ushort& x): type(U_SHORT), data(const_cast<Ushort*>(&x)) { }
         Index(const Short& x): type(SHORT), data(const_cast<Short*>(&x)) { }
         Index(const Uint& x): type(U_INT), data(const_cast<Uint*>(&x)) { }
         Index(const Int& x): type(INT), data(const_cast<Int*>(&x)) { }
         Index(const Ubigint& x): type(U_BIGINT), data(const_cast<Ubigint*>(&x)) { }
         Index(const Bigint& x): type(BIGINT), data(const_cast<Bigint*>(&x)) { }
         Index(const Float& x): type(FLOAT), data(const_cast<Float*>(&x)) { }
         Index(const Double& x): type(DOUBLE), data(const_cast<Double*>(&x)) { }
         Index(const Time& x): type(TIME), data(const_cast<Time*>(&x)) { }
         Index(const Date& x): type(DATE), data(const_cast<Date*>(&x)) { }
         Index(const Datetime& x): type(DATETIME), data(const_cast<Datetime*>(&x)) { }
         Index(const Blob& x): type(BLOB), data(const_cast<Blob*>(&x)) { }
         Index(const Text& x): type(TEXT), data(const_cast<Text*>(&x)) { }
         Index(const Wtext& x): type(WTEXT), data(const_cast<Wtext*>(&x)) { }
         Index(const Boolean& x): type(U_TINY), data(const_cast<Boolean*>(&x)) { }
         Index(const char* const x, const size_t size_): type(CHAR), data(const_cast<char*>(x)), size(size_) { }
         template<class T> explicit Index(const T& x): type(BINARY), data(const_cast<T*>(&x)), size(sizeof(T)) { }
         Index(const UtinyN& x): type(U_TINY_N), data(const_cast<UtinyN*>(&x)) { }
         Index(const TinyN& x): type(TINY_N), data(const_cast<TinyN*>(&x)) { }
         Index(const UshortN& x): type(U_SHORT_N), data(const_cast<UshortN*>(&x)) { }
         Index(const ShortN& x): type(SHORT_N), data(const_cast<ShortN*>(&x)) { }
         Index(const UintN& x): type(U_INT_N), data(const_cast<UintN*>(&x)) { }
         Index(const IntN& x): type(INT_N), data(const_cast<IntN*>(&x)) { }
         Index(const UbigintN& x): type(U_BIGINT_N), data(const_cast<UbigintN*>(&x)) { }
         Index(const BigintN& x): type(BIGINT_N), data(const_cast<BigintN*>(&x)) { }
         Index(const FloatN& x): type(FLOAT_N), data(const_cast<FloatN*>(&x)) { }
         Index(const DoubleN& x): type(DOUBLE_N), data(const_cast<DoubleN*>(&x)) { }
         Index(const TimeN& x): type(TIME_N), data(const_cast<TimeN*>(&x)) { }
         Index(const DateN& x): type(DATE_N), data(const_cast<DateN*>(&x)) { }
         Index(const DatetimeN& x): type(DATETIME_N), data(const_cast<DatetimeN*>(&x)) { }
         Index(const TextN& x): type(TEXT_N), data(const_cast<TextN*>(&x)) { }
         Index(const WtextN& x): type(WTEXT_N), data(const_cast<WtextN*>(&x)) { }
         Index(const BooleanN& x): type(U_TINY_N), data(const_cast<BooleanN*>(&x)) { }
         template<int size_> Index(const NullableArray<char, size_>& x): type(CHAR_N), data(const_cast<NullableArray<char, size_>*>(&x)), size(size_) { }
         template<class T> explicit Index(const Nullable<T>& x): type(BINARY_N), data(const_cast<Nullable<T>*>(&x)), size(sizeof(T)) { }

         Index(const Index& x): type(x.type), data(x.data), size(x.size) {}
         Index(): type(NOTHING), data(0), size(0) {}

         const Index& operator=(const Index& x) { type=x.type; data=x.data; size=x.size; return *this; }
         bool operator==(const Index& x) { return type==x.type && data==x.data && size==x.size; }
      };


      struct Set
      {

         virtual size_t numberOfSqlElements() const =0;


         virtual Index getSqlIndex(const size_t index) const =0; 

         virtual ~Set() {}
      };


      template<class T> class SetBuilder: public Set
      {
      public:
         T data;
         SetBuilder() {}
      private:
         virtual size_t numberOfSqlElements() const { return data.numberOfSqlElements(); }
         virtual Index getSqlIndex(const size_t index) const { return data.getSqlIndex(index); }
      };


      template<class T> class SetRefBuilder: public Set
      {
         virtual size_t numberOfSqlElements() const { return m_data.numberOfSqlElements(); }
         virtual Index getSqlIndex(const size_t index) const { return m_data.getSqlIndex(index); }
         const T& m_data;
      public:
         inline SetRefBuilder(const T& x): m_data(x) {}
      };


      template<class T> class SetPtrBuilder: public Set
      {
         const T* m_data;

         virtual size_t numberOfSqlElements() const { return m_data->numberOfSqlElements(); }

         virtual Index getSqlIndex(const size_t index) const { return m_data->getSqlIndex(index); }
      public:
         inline SetPtrBuilder(): m_data(0) {}

         inline SetPtrBuilder(const T& x): m_data(&x) {}

         inline SetPtrBuilder(SetPtrBuilder& x): m_data(x.m_data) {}

         inline void set(const T& data) { m_data=&data; }

         inline void clear() { m_data=0; }

         operator bool() const { return m_data; }
      };


      template<class T> class SetSharedPtrBuilder: public Set
      {
         virtual size_t numberOfSqlElements() const { return data->numberOfSqlElements(); }
      public:
         virtual Index getSqlIndex(const size_t index) const { return data->getSqlIndex(index); }
         inline SetSharedPtrBuilder() {}
         inline SetSharedPtrBuilder(const boost::shared_ptr<T>& x): data(x) {}
         inline SetSharedPtrBuilder(SetSharedPtrBuilder& x): data(x.data) {}
         boost::shared_ptr<T> data;
      };


      template<class T> class IndySetBuilder: public Set
      {
      public:
         T data;
         IndySetBuilder() {}
      private:
         virtual size_t numberOfSqlElements() const { return 1; }
         virtual Index getSqlIndex(const size_t index) const { return data; }
      };


      template<class T> class IndySetRefBuilder: public Set
      {
         const T& data;
         virtual size_t numberOfSqlElements() const { return 1; }
         virtual Index getSqlIndex(const size_t index) const { return data; }
      public:
         inline IndySetRefBuilder(const T& x): data(x) {}
      };


      template<class T> class IndySetPtrBuilder: public Set
      {
         const T* m_data;

         virtual size_t numberOfSqlElements() const { return 1; }
          
         virtual Index getSqlIndex(const size_t index) const { return *m_data; }
      public:
         inline IndySetPtrBuilder(): m_data(0) {}

         inline IndySetPtrBuilder(const T& x): m_data(&x) {}

         inline IndySetPtrBuilder(IndySetPtrBuilder& x): m_data(x.m_data) {}

         inline void set(const T& data) { m_data=&data; }

         inline void clear() { m_data=0; }

         operator bool() const { return m_data; }
      };

      struct SetContainer
      {
         virtual Set& manufacture() =0;
         virtual void trim() =0;
         virtual ~SetContainer() {}

         virtual const Set* pull() const =0;
         virtual void init() const =0;
      };


      template<class T> class STLSetContainer: public SetContainer
      {
         mutable SetPtrBuilder<typename T::value_type> m_buffer;
         mutable typename T::iterator m_itBuffer;

         Set& manufacture()
         {
            data.push_back(typename T::value_type());
            m_buffer.set(data.back());
            return m_buffer;
         }
         void trim() { data.pop_back(); }
         const Set* pull() const
         {
            if(m_itBuffer == const_cast<T&>(data).end()) return 0;
            m_buffer.set(*m_itBuffer++);
            return &m_buffer;
         }
      public:
         T data;
         void init() const {  m_itBuffer = const_cast<T&>(data).begin(); }
         STLSetContainer(): m_itBuffer(data.begin()) {}
      };
   

      template<class T> class IndySTLSetContainer: public SetContainer
      {
         mutable IndySetPtrBuilder<typename T::value_type> m_buffer;
         mutable typename T::iterator m_itBuffer;

         Set& manufacture()
         {
            data.push_back(typename T::value_type());
            m_buffer.set(data.back());
            return m_buffer;
         }
         void trim() { data.pop_back(); }
         const Set* pull() const
         {
            if(m_itBuffer == const_cast<T&>(data).end()) return 0;
            m_buffer.set(*m_itBuffer++);
            return &m_buffer;
         }
      public:
         T data;
         void init() const {  m_itBuffer = const_cast<T&>(data).begin(); }
         IndySTLSetContainer(): m_itBuffer(data.begin()) {}
      };
   

      template<class T> class STLSetRefContainer: public SetContainer
      {
         T& data;
         mutable SetPtrBuilder<typename T::value_type> m_buffer;
         mutable typename T::iterator m_itBuffer;

         Set& manufacture()
         {
            data.push_back(typename T::value_type());
            m_buffer.set(data.back());
            return m_buffer;
         }
         void trim() { data.pop_back(); }
         const Set* pull() const
         {
            if(m_itBuffer == const_cast<T&>(data).end()) return 0;
            m_buffer.set(*m_itBuffer++);
            return &m_buffer;
         }
      public:
         void init() const {  m_itBuffer = const_cast<T&>(data).begin(); }
         STLSetRefContainer(T& x): data(x), m_itBuffer(data.begin()) {}
      };
   

      template<class T> class STLSharedSetContainer: public SetContainer
      {
         mutable SetPtrBuilder<typename T::value_type> m_buffer;
         mutable typename T::iterator m_itBuffer;

         Set& manufacture()
         {
            data->push_back(typename T::value_type());
            m_buffer.set(data->back());
            return m_buffer;
         }
         void trim() { data->pop_back(); }
         const Set* pull() const
         {
            if(m_itBuffer == const_cast<T*>(data)->end()) return 0;
            m_buffer.set(*m_itBuffer++);
            return &m_buffer;
         }
      public:
         boost::shared_ptr<T> data;
         STLSharedSetContainer(const boost::shared_ptr<T>& x): data(x) {}
         STLSharedSetContainer(): m_itBuffer(data->begin()) {}
         void init() const {  m_itBuffer = const_cast<T*>(data)->begin(); }
      };

      struct Conversion
      {

         virtual void* getPointer() =0;

         virtual void convertResult() =0;

         virtual void convertParam() =0;

         void* external;
      };
      
      typedef std::map<int, boost::shared_ptr<Conversion> > Conversions;
   }
}

#endif