1000 lines
31 KiB
C++
1000 lines
31 KiB
C++
//
|
|
// Copyright (c) 2019-2024 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
|
|
#ifndef BOOST_MYSQL_FIELD_HPP
|
|
#define BOOST_MYSQL_FIELD_HPP
|
|
|
|
#include <boost/mysql/blob.hpp>
|
|
#include <boost/mysql/field_kind.hpp>
|
|
#include <boost/mysql/field_view.hpp>
|
|
#include <boost/mysql/string_view.hpp>
|
|
|
|
#include <boost/mysql/detail/config.hpp>
|
|
#include <boost/mysql/detail/field_impl.hpp>
|
|
|
|
#include <boost/variant2/variant.hpp>
|
|
|
|
#include <cstddef>
|
|
#include <iosfwd>
|
|
#include <string>
|
|
#ifdef __cpp_lib_string_view
|
|
#include <string_view>
|
|
#endif
|
|
|
|
namespace boost {
|
|
namespace mysql {
|
|
|
|
/**
|
|
* \brief Variant-like class that can represent of any of the allowed database types.
|
|
* \details
|
|
* This is a regular variant-like class that can represent any of the types that MySQL allows. It
|
|
* has value semantics (as opposed to \ref field_view). Instances of this class are not created
|
|
* by the library. They should be created by the user, when the reference semantics of
|
|
* \ref field_view are not appropriate.
|
|
* \n
|
|
* Like a variant, at any point, a `field` always contains a value of
|
|
* certain type. You can query the type using \ref kind and the `is_xxx` functions
|
|
* like \ref is_int64. Use `as_xxx` and `get_xxx` for checked and unchecked value
|
|
* access, respectively. You can mutate a `field` by calling the assignment operator,
|
|
* or using the lvalue references returned by `as_xxx` and `get_xxx`.
|
|
*/
|
|
class field
|
|
{
|
|
public:
|
|
/**
|
|
* \brief Constructs a `field` holding NULL.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
field() = default;
|
|
|
|
/**
|
|
* \brief Copy constructor.
|
|
* \par Exception safety
|
|
* Strong guarantee. Internal allocations may throw.
|
|
*/
|
|
field(const field&) = default;
|
|
|
|
/**
|
|
* \brief Move constructor.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* All references into `other` are invalidated, including the ones obtained by calling
|
|
* get_xxx, as_xxx and \ref field::operator field_view().
|
|
*/
|
|
field(field&& other) = default;
|
|
|
|
/**
|
|
* \brief Copy assignment.
|
|
* \par Exception safety
|
|
* Basic guarantee. Internal allocations may throw.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(const field&) = default;
|
|
|
|
/**
|
|
* \brief Move assignment.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references to `*this` obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view(). All references into `other`
|
|
* are invalidated, including the ones obtained by calling get_xxx, as_xxx and
|
|
* \ref field::operator field_view().
|
|
*/
|
|
field& operator=(field&& other) = default;
|
|
|
|
/// Destructor.
|
|
~field() = default;
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding NULL.
|
|
* \details
|
|
* Caution: `field(NULL)` will __NOT__ match this overload. It will try to construct
|
|
* a `string_view` from a NULL C string, causing undefined behavior.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(std::nullptr_t) noexcept {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding an `int64`.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(signed char v) noexcept : repr_(std::int64_t(v)) {}
|
|
|
|
/// \copydoc field(signed char)
|
|
explicit field(short v) noexcept : repr_(std::int64_t(v)) {}
|
|
|
|
/// \copydoc field(signed char)
|
|
explicit field(int v) noexcept : repr_(std::int64_t(v)) {}
|
|
|
|
/// \copydoc field(signed char)
|
|
explicit field(long v) noexcept : repr_(std::int64_t(v)) {}
|
|
|
|
/// \copydoc field(signed char)
|
|
explicit field(long long v) noexcept : repr_(std::int64_t(v)) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding an `uint64`.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(unsigned char v) noexcept : repr_(std::uint64_t(v)) {}
|
|
|
|
/// \copydoc field(unsigned char)
|
|
explicit field(unsigned short v) noexcept : repr_(std::uint64_t(v)) {}
|
|
|
|
/// \copydoc field(unsigned char)
|
|
explicit field(unsigned int v) noexcept : repr_(std::uint64_t(v)) {}
|
|
|
|
/// \copydoc field(unsigned char)
|
|
explicit field(unsigned long v) noexcept : repr_(std::uint64_t(v)) {}
|
|
|
|
/// \copydoc field(unsigned char)
|
|
explicit field(unsigned long long v) noexcept : repr_(std::uint64_t(v)) {}
|
|
|
|
/**
|
|
* \brief Constructors from character types would incorrectly construct a `field` holding an integer,
|
|
* so they are not allowed.
|
|
*/
|
|
explicit field(char) = delete;
|
|
|
|
/// \copydoc field(char)
|
|
explicit field(wchar_t) = delete;
|
|
|
|
/// \copydoc field(char)
|
|
explicit field(char16_t) = delete;
|
|
|
|
/// \copydoc field(char)
|
|
explicit field(char32_t) = delete;
|
|
|
|
#ifdef __cpp_char8_t
|
|
/// \copydoc field(char)
|
|
explicit field(char8_t) = delete;
|
|
#endif
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a string.
|
|
* \par Exception safety
|
|
* Strong guarantee. Internal allocations may throw.
|
|
*/
|
|
explicit field(const std::string& v) : repr_(v) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a string.
|
|
* \details v is moved into an internal `std::string` object.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(std::string&& v) noexcept : repr_(std::move(v)) {}
|
|
|
|
/// \copydoc field(const std::string&)
|
|
explicit field(const char* v) : repr_(boost::variant2::in_place_type_t<std::string>(), v) {}
|
|
|
|
/// \copydoc field(const std::string&)
|
|
explicit field(string_view v) : repr_(boost::variant2::in_place_type_t<std::string>(), v) {}
|
|
|
|
#if defined(__cpp_lib_string_view)
|
|
/// \copydoc field(const std::string&)
|
|
explicit field(std::string_view v) noexcept : repr_(boost::variant2::in_place_type_t<std::string>(), v) {}
|
|
#endif
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a `blob`.
|
|
* \details v is moved into an internal `blob` object.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(blob v) noexcept : repr_(std::move(v)) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a `float`.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(float v) noexcept : repr_(v) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a `double`.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(double v) noexcept : repr_(v) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a `date`.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(const date& v) noexcept : repr_(v) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a `datetime`.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(const datetime& v) noexcept : repr_(v) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` holding a `time`.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
explicit field(const time& v) noexcept : repr_(v) {}
|
|
|
|
/**
|
|
* \brief Constructs a `field` from a \ref field_view.
|
|
* \details The resulting `field` has the same kind and value as the original `field_view`.
|
|
*
|
|
* \par Exception safety
|
|
* Strong guarantee. Internal allocations may throw.
|
|
*
|
|
* \par Object lifetimes
|
|
* The resulting `field` is guaranteed to be valid even after `v` becomes invalid.
|
|
*/
|
|
field(const field_view& v) { from_view(v); }
|
|
|
|
/**
|
|
* \brief Replaces `*this` with a `NULL`, changing the kind to `null` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(std::nullptr_t) noexcept
|
|
{
|
|
repr_.data.emplace<detail::field_impl::null_t>();
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `int64` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(signed char v) noexcept
|
|
{
|
|
repr_.data.emplace<std::int64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(signed char)
|
|
field& operator=(short v) noexcept
|
|
{
|
|
repr_.data.emplace<std::int64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(signed char)
|
|
field& operator=(int v) noexcept
|
|
{
|
|
repr_.data.emplace<std::int64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(signed char)
|
|
field& operator=(long v) noexcept
|
|
{
|
|
repr_.data.emplace<std::int64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(signed char)
|
|
field& operator=(long long v) noexcept
|
|
{
|
|
repr_.data.emplace<std::int64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `uint64` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(unsigned char v) noexcept
|
|
{
|
|
repr_.data.emplace<std::uint64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(unsigned char)
|
|
field& operator=(unsigned short v) noexcept
|
|
{
|
|
repr_.data.emplace<std::uint64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(unsigned char)
|
|
field& operator=(unsigned int v) noexcept
|
|
{
|
|
repr_.data.emplace<std::uint64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(unsigned char)
|
|
field& operator=(unsigned long v) noexcept
|
|
{
|
|
repr_.data.emplace<std::uint64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(unsigned char)
|
|
field& operator=(unsigned long long v) noexcept
|
|
{
|
|
repr_.data.emplace<std::uint64_t>(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Assignments from character types would incorrectly assign an integer,
|
|
* so they are not allowed.
|
|
*/
|
|
field& operator=(char) = delete;
|
|
|
|
/// \copydoc operator=(char)
|
|
field& operator=(wchar_t) = delete;
|
|
|
|
/// \copydoc operator=(char)
|
|
field& operator=(char16_t) = delete;
|
|
|
|
/// \copydoc operator=(char)
|
|
field& operator=(char32_t) = delete;
|
|
|
|
#ifdef __cpp_char8_t
|
|
/// \copydoc operator=(char)
|
|
field& operator=(char8_t) = delete;
|
|
#endif
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `string` and destroying any previous
|
|
* contents.
|
|
*
|
|
* \par Exception safety
|
|
* Basic guarantee. Internal allocations may throw.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(const std::string& v)
|
|
{
|
|
repr_.data.emplace<std::string>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(const std::string&)
|
|
field& operator=(std::string&& v)
|
|
{
|
|
repr_.data.emplace<std::string>(std::move(v));
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(const std::string&)
|
|
field& operator=(const char* v)
|
|
{
|
|
repr_.data.emplace<std::string>(v);
|
|
return *this;
|
|
}
|
|
|
|
/// \copydoc operator=(const std::string&)
|
|
field& operator=(string_view v)
|
|
{
|
|
repr_.data.emplace<std::string>(v);
|
|
return *this;
|
|
}
|
|
|
|
#if defined(__cpp_lib_string_view)
|
|
/// \copydoc operator=(const std::string&)
|
|
field& operator=(std::string_view v)
|
|
{
|
|
repr_.data.emplace<std::string>(v);
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `blob` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* Basic guarantee. Internal allocations may throw.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(blob v)
|
|
{
|
|
repr_.data.emplace<blob>(std::move(v));
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `float_` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(float v) noexcept
|
|
{
|
|
repr_.data.emplace<float>(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `double` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(double v) noexcept
|
|
{
|
|
repr_.data.emplace<double>(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `date` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(const date& v) noexcept
|
|
{
|
|
repr_.data.emplace<date>(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `datetime` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions,
|
|
* but not the ones obtained by \ref field::operator field_view().
|
|
*/
|
|
field& operator=(const datetime& v) noexcept
|
|
{
|
|
repr_.data.emplace<datetime>(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `time` and destroying any
|
|
* previous contents.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references obtained by as_xxx and get_xxx functions, but not
|
|
*/
|
|
field& operator=(const time& v) noexcept
|
|
{
|
|
repr_.data.emplace<time>(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Replaces `*this` with `v`, changing the kind to `v.kind()` and destroying any previous
|
|
* contents.
|
|
*
|
|
* \par Exception safety
|
|
* Basic guarantee. Internal allocations may throw.
|
|
*
|
|
* \par Object lifetimes
|
|
* Invalidates references to `*this` obtained by as_xxx and get_xxx functions, but not
|
|
* the ones obtained by \ref field::operator field_view().
|
|
*\n
|
|
* `*this` is guaranteed to be valid even after `v` becomes invalid.
|
|
*/
|
|
field& operator=(const field_view& v)
|
|
{
|
|
from_view(v);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* \brief Returns the type of the value this `field` is holding.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
field_kind kind() const noexcept { return repr_.kind(); }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `NULL` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_null() const noexcept { return kind() == field_kind::null; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `int64` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_int64() const noexcept { return kind() == field_kind::int64; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `uint64` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_uint64() const noexcept { return kind() == field_kind::uint64; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a string value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_string() const noexcept { return kind() == field_kind::string; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a blob value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_blob() const noexcept { return kind() == field_kind::blob; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `float` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_float() const noexcept { return kind() == field_kind::float_; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `double` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_double() const noexcept { return kind() == field_kind::double_; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `date` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_date() const noexcept { return kind() == field_kind::date; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `datetime` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_datetime() const noexcept { return kind() == field_kind::datetime; }
|
|
|
|
/**
|
|
* \brief Returns whether this `field` is holding a `time` value.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
bool is_time() const noexcept { return kind() == field_kind::time; }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `std::int64_t` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_int64()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const std::int64_t& as_int64() const { return repr_.as<std::int64_t>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `std::uint64_t` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_uint64()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const std::uint64_t& as_uint64() const { return repr_.as<std::uint64_t>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `std::string` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_string()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const std::string& as_string() const { return repr_.as<std::string>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `blob` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_blob()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const blob& as_blob() const { return repr_.as<blob>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `float` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_float()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const float& as_float() const { return repr_.as<float>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `double` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_double()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const double& as_double() const { return repr_.as<double>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `date` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_date()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const date& as_date() const { return repr_.as<date>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `datetime` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_datetime()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const datetime& as_datetime() const { return repr_.as<datetime>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `time` value or throws an exception.
|
|
* \par Exception safety
|
|
* Strong guarantee. Throws on type mismatch.
|
|
* \throws bad_field_access If `!this->is_time()`
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const time& as_time() const { return repr_.as<time>(); }
|
|
|
|
/// \copydoc as_int64
|
|
std::int64_t& as_int64() { return repr_.as<std::int64_t>(); }
|
|
|
|
/// \copydoc as_uint64
|
|
std::uint64_t& as_uint64() { return repr_.as<std::uint64_t>(); }
|
|
|
|
/// \copydoc as_string
|
|
std::string& as_string() { return repr_.as<std::string>(); }
|
|
|
|
/// \copydoc as_blob
|
|
blob& as_blob() { return repr_.as<blob>(); }
|
|
|
|
/// \copydoc as_float
|
|
float& as_float() { return repr_.as<float>(); }
|
|
|
|
/// \copydoc as_double
|
|
double& as_double() { return repr_.as<double>(); }
|
|
|
|
/// \copydoc as_date
|
|
date& as_date() { return repr_.as<date>(); }
|
|
|
|
/// \copydoc as_datetime
|
|
datetime& as_datetime() { return repr_.as<datetime>(); }
|
|
|
|
/// \copydoc as_time
|
|
time& as_time() { return repr_.as<time>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `std::int64_t` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_int64() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const std::int64_t& get_int64() const noexcept { return repr_.get<std::int64_t>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `std::uint64_t` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_uint64() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const std::uint64_t& get_uint64() const noexcept { return repr_.get<std::uint64_t>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `std::string` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_string() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const std::string& get_string() const noexcept { return repr_.get<std::string>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `blob` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_blob() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const blob& get_blob() const noexcept { return repr_.get<blob>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `float` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_float() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const float& get_float() const noexcept { return repr_.get<float>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `double` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_double() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const double& get_double() const noexcept { return repr_.get<double>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `date` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_date() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const date& get_date() const noexcept { return repr_.get<date>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `datetime` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_datetime() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const datetime& get_datetime() const noexcept { return repr_.get<datetime>(); }
|
|
|
|
/**
|
|
* \brief Retrieves a reference to the underlying `time` value (unchecked access).
|
|
* \par Preconditions
|
|
* `this->is_time() == true` (if violated, results in undefined behavior).
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned reference is valid as long as `*this` is alive and no function that invalidates
|
|
* references is called on `*this`.
|
|
*/
|
|
const time& get_time() const noexcept { return repr_.get<time>(); }
|
|
|
|
/// \copydoc get_int64
|
|
std::int64_t& get_int64() noexcept { return repr_.get<std::int64_t>(); }
|
|
|
|
/// \copydoc get_uint64
|
|
std::uint64_t& get_uint64() noexcept { return repr_.get<std::uint64_t>(); }
|
|
|
|
/// \copydoc get_string
|
|
std::string& get_string() noexcept { return repr_.get<std::string>(); }
|
|
|
|
/// \copydoc get_blob
|
|
blob& get_blob() noexcept { return repr_.get<blob>(); }
|
|
|
|
/// \copydoc get_float
|
|
float& get_float() noexcept { return repr_.get<float>(); }
|
|
|
|
/// \copydoc get_double
|
|
double& get_double() noexcept { return repr_.get<double>(); }
|
|
|
|
/// \copydoc get_date
|
|
date& get_date() noexcept { return repr_.get<date>(); }
|
|
|
|
/// \copydoc get_datetime
|
|
datetime& get_datetime() noexcept { return repr_.get<datetime>(); }
|
|
|
|
/// \copydoc get_time
|
|
time& get_time() noexcept { return repr_.get<time>(); }
|
|
|
|
/**
|
|
* \brief Constructs a \ref field_view pointing to `*this`.
|
|
* \details The resulting `field_view` has the same kind and value as `*this`.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*
|
|
* \par Object lifetimes
|
|
* The returned object acts as a
|
|
* reference to `*this`, and will be valid as long as `*this` is alive.
|
|
*/
|
|
inline operator field_view() const noexcept { return field_view(&repr_); }
|
|
|
|
private:
|
|
detail::field_impl repr_;
|
|
|
|
BOOST_MYSQL_DECL
|
|
void from_view(const field_view& v);
|
|
};
|
|
|
|
/**
|
|
* \relates field
|
|
* \brief Tests for equality.
|
|
* \details The same considerations as \ref field_view::operator== apply.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
inline bool operator==(const field& lhs, const field& rhs) noexcept
|
|
{
|
|
return field_view(lhs) == field_view(rhs);
|
|
}
|
|
|
|
/**
|
|
* \relates field
|
|
* \brief Tests for inequality.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
inline bool operator!=(const field& lhs, const field& rhs) noexcept { return !(lhs == rhs); }
|
|
|
|
/**
|
|
* \relates field
|
|
* \brief Tests for equality.
|
|
* \details The same considerations as \ref field_view::operator== apply.
|
|
*
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
inline bool operator==(const field_view& lhs, const field& rhs) noexcept { return lhs == field_view(rhs); }
|
|
|
|
/**
|
|
* \relates field
|
|
* \brief Tests for inequality.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
inline bool operator!=(const field_view& lhs, const field& rhs) noexcept { return !(lhs == rhs); }
|
|
|
|
/**
|
|
* \relates field
|
|
* \brief Tests for equality.
|
|
* \details The same considerations as \ref field_view::operator== apply.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
inline bool operator==(const field& lhs, const field_view& rhs) noexcept { return field_view(lhs) == rhs; }
|
|
|
|
/**
|
|
* \relates field
|
|
* \brief Tests for inequality.
|
|
* \par Exception safety
|
|
* No-throw guarantee.
|
|
*/
|
|
inline bool operator!=(const field& lhs, const field_view& rhs) noexcept { return !(lhs == rhs); }
|
|
|
|
/**
|
|
* \relates field
|
|
* \brief Streams a `field`.
|
|
*/
|
|
BOOST_MYSQL_DECL
|
|
std::ostream& operator<<(std::ostream& os, const field& v);
|
|
|
|
} // namespace mysql
|
|
} // namespace boost
|
|
|
|
#ifdef BOOST_MYSQL_HEADER_ONLY
|
|
#include <boost/mysql/impl/field.ipp>
|
|
#endif
|
|
|
|
#endif
|