cppmariadb/include/cppmariadb/field.inl

#pragma once

#include <cppcore/conversion/string.h>

#include "enums.h"
#include "field.h"
#include "exception.h"

#include "column.inl"

namespace cppmariadb
{

    /* op_field_converter ************************************************************************/

    template<class T, class Enable = void>
    struct op_field_converter;

    template<typename T>
    struct op_field_converter<T, void>
    {
        inline T operator()(const char* c, size_t s) const
        {
            T tmp;
            std::string data(c, s);
            if (!cppcore::try_from_string(data, tmp))
                throw exception(std::string("unable to convert field data (data=") + data + ")", error_code::UnknownError);
            return tmp;
        }
    };

    template<>
    struct op_field_converter<const char*, void>
    {
        inline const char* operator()(const char* c, size_t s) const
            { return c; }
    };

    template<>
    struct op_field_converter<std::string, void>
    {
        inline std::string operator()(const char* c, size_t s) const
            { return std::string(c, s); }
    };

    /* field *************************************************************************************/

    field::field(
        const row&  p_row,
        size_t      p_index,
        const char* p_data,
        size_t      p_size)
            : _row  (p_row)
            , _index(p_index)
            , _data (p_data)
            , _size (p_size)
            { }

    size_t field::index() const
        { return _index; }

    const column& field::column() const
        { return _row.columns().at(_index); }

    bool field::is_null() const
        { return (_data == nullptr); }

    bool field::is_empty() const
        { return (_size == 0); }

    const char* field::data() const
        { return _data; }

    size_t field::size() const
        { return _size; }

    template <class T>
    T field::get() const
    {
        if (is_null())
            throw exception("field is null", error_code::UnknownError);
        return op_field_converter<T>()(_data, _size);
    }

    field::operator bool() const
        { return !is_null() && !is_empty(); }

}