parameters.hpp

Go to the documentation of this file.

 
/*******************************************************************************
* Copyright (C) 2020 Eddie Carle [eddie@isatec.ca]                             *
*                                                                              *
* This file is part of fastcgi++.                                              *
*                                                                              *
* fastcgi++ is free software: you can redistribute it and/or modify it under   *
* the terms of the GNU Lesser General Public License as  published by the Free *
* Software Foundation, either version 3 of the License, or (at your option)    *
* any later version.                                                           *
*                                                                              *
* fastcgi++ is distributed in the hope that it will be useful, but WITHOUT ANY *
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS    *
* FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for     *
* more details.                                                                *
*                                                                              *
* You should have received a copy of the GNU Lesser General Public License     *
* along with fastcgi++.  If not, see <http://www.gnu.org/licenses/>.           *
*******************************************************************************/
 
#ifndef FASTCGIPP_SQL_PARAMETERS_HPP
#define FASTCGIPP_SQL_PARAMETERS_HPP
 
#include "fastcgi++/endian.hpp"
#include "fastcgi++/address.hpp"
 
#include <tuple>
#include <string>
#include <vector>
#include <chrono>
#include <memory>
 
namespace Fastcgipp
{
    namespace SQL
    {
 
        template<typename T> class Parameter;
 
        template<>
        class Parameter<bool>
        {
        private:
            char m_data;
        public:
            static const unsigned oid;
            constexpr Parameter(bool x) noexcept:
                m_data(static_cast<char>(x))
            {}
            constexpr Parameter& operator=(bool x) noexcept
            {
                m_data = static_cast<char>(x);
                return *this;
            }
            constexpr const char* data() const
            {
                return &m_data;
            }
            constexpr unsigned size() const
            {
                return 1;
            }
        };
 
        template<>
        struct Parameter<int16_t>: public BigEndian<int16_t>
        {
            using BigEndian<int16_t>::BigEndian;
            using BigEndian<int16_t>::operator=;
            static const unsigned oid;
        };
 
        template<>
        struct Parameter<int32_t>: public BigEndian<int32_t>
        {
            using BigEndian<int32_t>::BigEndian;
            using BigEndian<int32_t>::operator=;
            static const unsigned oid;
        };
 
        template<>
        struct Parameter<int64_t>: public BigEndian<int64_t>
        {
            using BigEndian<int64_t>::BigEndian;
            using BigEndian<int64_t>::operator=;
            static const unsigned oid;
        };
 
        template<>
        struct Parameter<float>: public BigEndian<float>
        {
            using BigEndian<float>::BigEndian;
            using BigEndian<float>::operator=;
            static const unsigned oid;
        };
 
        template<>
        struct Parameter<double>: public BigEndian<double>
        {
            using BigEndian<double>::BigEndian;
            using BigEndian<double>::operator=;
            static const unsigned oid;
        };
 
        template<>
        struct Parameter<std::string>: public std::string
        {
            Parameter(const std::string& x):
                std::string(x)
            {}
            using std::string::string;
            using std::string::operator=;
            static const unsigned oid;
        };
 
        template<>
        struct Parameter<std::vector<char>>: public std::vector<char>
        {
            Parameter(const std::vector<char>& x):
                std::vector<char>(x)
            {}
            using std::vector<char>::vector;
            using std::vector<char>::operator=;
            static const unsigned oid;
        };
 
        template<>
        class Parameter<std::wstring>: public std::string
        {
        private:
            static std::string convert(const std::wstring& x);
 
        public:
            Parameter& operator=(const std::wstring& x)
            {
                 assign(convert(x));
                 return *this;
            }
 
            Parameter(const std::wstring& x):
                std::string(convert(x))
            {}
 
            static const unsigned oid;
        };
 
        template<>
        class Parameter<std::chrono::time_point<std::chrono::system_clock>>:
            public BigEndian<int64_t>
        {
        private:
            using BigEndian<int64_t>::operator=;
            static int64_t convert(
                    const std::chrono::time_point<std::chrono::system_clock>& x)
            {
                return std::chrono::duration_cast<
                    std::chrono::duration<int64_t, std::micro>>(
                        x.time_since_epoch()-std::chrono::seconds(946684800)).count();
            }
 
        public:
            Parameter& operator=(
                    const std::chrono::time_point<std::chrono::system_clock>& x)
            {
                *this = convert(x);
                return *this;
            }
 
            Parameter(
                    const std::chrono::time_point<std::chrono::system_clock>& x):
                BigEndian<int64_t>(convert(x))
            {}
 
            static const unsigned oid;
        };
 
        template<>
        struct Parameter<Address>: public std::array<char, 20>
        {
            Parameter& operator=(const Address& x)
            {
                auto next = begin();
                *next++ = addressFamily;
                *next++ = 128;
                *next++ = 0;
                *next++ = 16;
                next = std::copy_n(
                        reinterpret_cast<const char*>(&x),
                        Address::size,
                        next);
                return *this;
            }
            Parameter(const Address& x)
            {
                *this = x;
            }
            static const unsigned oid;
            static const char addressFamily;
        };
 
        template<typename Numeric>
        class Parameter<std::vector<Numeric>>
        {
        private:
            static_assert(
                    std::is_integral<Numeric>::value ||
                        std::is_floating_point<Numeric>::value,
                    "Numeric must be a numeric type.");
            unsigned m_size;
            std::unique_ptr<char[]> m_data;
        public:
            void resize(const unsigned size);
 
            Parameter& operator=(const std::vector<Numeric>& x);
 
            Parameter(const std::vector<Numeric>& x)
            {
                *this = x;
            }
 
            Parameter(const unsigned size)
            {
                resize(size);
            }
 
            BigEndian<Numeric>& operator[](const unsigned i)
            {
                return *reinterpret_cast<BigEndian<Numeric>*>(
                        m_data.get() + 6*sizeof(int32_t)
                        + i*(sizeof(int32_t) + sizeof(Numeric)));
            }
 
            unsigned size() const
            {
                return m_size;
            }
 
            const char* data() const
            {
                return m_data.get();
            }
 
            static const unsigned oid;
        };
 
        template<>
        class Parameter<std::vector<std::string>>
        {
        private:
            unsigned m_size;
            std::unique_ptr<char[]> m_data;
        protected:
            void assign(const std::vector<std::string>& x);
        public:
            Parameter& operator=(const std::vector<std::string>& x)
            {
                assign(x);
                return *this;
            }
 
            Parameter(const std::vector<std::string>& x)
            {
                assign(x);
            }
 
            std::string operator[](const unsigned i) const;
 
            unsigned size() const
            {
                return m_size;
            }
 
            const char* data() const
            {
                return m_data.get();
            }
 
            static const unsigned oid;
        };
 
        template<>
        class Parameter<std::vector<std::wstring>>:
            public Parameter<std::vector<std::string>>
        {
        private:
            static std::vector<std::string> convert(
                    const std::vector<std::wstring>& x);
            static std::wstring convert(const std::string& x);
        public:
            Parameter& operator=(const std::vector<std::wstring>& x)
            {
                assign(convert(x));
                return *this;
            }
 
            Parameter(const std::vector<std::wstring>& x):
                Parameter<std::vector<std::string>>(convert(x))
            {}
 
            std::wstring operator[](const unsigned i) const
            {
                return convert(
                        Parameter<std::vector<std::string>>::operator[](i));
            }
        };
 
        class Parameters_base
        {
        protected:
 
            const std::vector<unsigned>* m_oids;
 
 
            std::vector<const char*> m_raws;
 
 
            std::vector<int> m_sizes;
 
 
            const std::vector<int>* m_formats;
 
 
            virtual void build_impl() =0;
 
        public:
            void build();
 
 
            const unsigned* oids() const
            {
                return m_oids->data();
            }
 
 
            const char* const* raws() const
            {
                return m_raws.data();
            }
 
            const int* sizes() const
            {
                return m_sizes.data();
            }
 
            const int* formats() const
            {
                return m_formats->data();
            }
 
            virtual int size() const =0;
 
            virtual ~Parameters_base() {}
        };
 
 
        template<typename... Types>
        class Parameters:
            public std::tuple<Parameter<Types>...>,
            public Parameters_base
        {
        private:
            static const std::vector<unsigned> s_oids;
            static const std::vector<int> s_formats;
 
            constexpr int size() const
            {
                return sizeof...(Types);
            }
 
            template<size_t column, size_t... columns>
            inline void build_impl(std::index_sequence<column, columns...>)
            {
                m_raws.push_back(std::get<column>(*this).data());
                m_sizes.push_back(std::get<column>(*this).size());
                build_impl(std::index_sequence<columns...>{});
            }
 
            template<size_t column>
            inline void build_impl(std::index_sequence<column>)
            {
                m_raws.push_back(std::get<column>(*this).data());
                m_sizes.push_back(std::get<column>(*this).size());
            }
 
            void build_impl();
 
        public:
            using std::tuple<Parameter<Types>...>::tuple;
            using std::tuple<Parameter<Types>...>::operator=;
        };
 
        template<typename... Types>
        std::shared_ptr<Parameters<Types...>> make_Parameters(
                const Types&... args)
        {
            return std::shared_ptr<Parameters<Types...>>(
                    new Parameters<Types...>(args...));
        }
 
        template<typename... Types>
        std::shared_ptr<Parameters<Types...>> make_Parameters(
                const std::tuple<Types...>& tuple)
        {
            return std::shared_ptr<Parameters<Types...>>(
                    new Parameters<Types...>(tuple));
        }
    }
}
 
template<typename... Types>
void Fastcgipp::SQL::Parameters<Types...>::build_impl()
{
    m_oids = &s_oids;
    m_formats = &s_formats;
    build_impl(std::index_sequence_for<Types...>{});
}
 
template<typename... Types>
const std::vector<unsigned> Fastcgipp::SQL::Parameters<Types...>::s_oids
{
    Fastcgipp::SQL::Parameter<Types>::oid...
};
 
template<typename... Types>
const std::vector<int> Fastcgipp::SQL::Parameters<Types...>::s_formats(
        sizeof...(Types),
        1);
 
#endif