error_internal.h

/*
 * Copyright (c) 2016, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0, as
 * published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms, as
 * designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * This program 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 General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/

#ifndef XAPI_INTERNAL_ERROR
#defineXAPI_INTERNAL_ERROR


classMysqlx_exception
{
public:

enum Mysqlx_exception_type {
 MYSQLX_EXCEPTION_INTERNAL, MYSQLX_EXCEPTION_EXTERNAL
 };

Mysqlx_exception(Mysqlx_exception_type t, uint32_t code, std::string message)
 : m_type(t), m_code(code), m_message(message)
 {}

Mysqlx_exception(std::string message)
 : m_message(message)
 {}

 std::string message() const { return m_message; }
 Mysqlx_exception_type type() const { return m_type; }
uint32_tcode() const { return m_code; }

protected:

Mysqlx_exception()
 {}

 Mysqlx_exception_type m_type = MYSQLX_EXCEPTION_INTERNAL;
uint32_t m_code = 0;
 std::string m_message;
};


typedefstructmysqlx_error_structmysqlx_error_t;

structMysqlx_diag_base
{
virtual~Mysqlx_diag_base() {}
virtualmysqlx_error_t * get_error() = 0;
};

typedefstructmysqlx_error_struct : publicMysqlx_diag_base
{
 std::string m_message;
unsignedint m_error_num;
bool m_is_warning;

mysqlx_error_struct() : m_error_num(0), m_is_warning(false)
 {}

mysqlx_error_struct(constchar *m, unsignedint n,
bool is_warning = false) :
m_is_warning(is_warning)
 {
set(m, n);
 }

mysqlx_error_struct(const cdk::Error* cdk_error,
bool is_warning = false) :
m_is_warning(is_warning)
 {
set(cdk_error);
 }

mysqlx_error_struct(const cdk::Error &cdk_error,
bool is_warning = false) :
m_is_warning(is_warning)
 {
set(&cdk_error);
 }

voidset(const Mysqlx_exception &ex)
 {
 m_message = ex.message();
 m_error_num = ex.code();
 }

voidset(constchar *m, unsignedint n)
 {
 m_message = std::string(m);
 m_error_num = n;
 }

voidset(const cdk::Error* cdk_error)
 {
if (!cdk_error)
 {
 m_message = "";
 m_error_num = 0;
return;
 }

 m_message = cdk_error->description();

if (!m_is_warning || cdk_error->code().category() == cdk::server_error_category())
 m_error_num = (unsignedint)cdk_error->code().value();
else
 m_error_num = 0;
 }

voidreset()
 {
set((const cdk::Error*)NULL);
 }

unsignedinterror_num()
 {
return m_error_num;
 }

constchar* message()
 {
return m_message.size() ? m_message.data() : NULL;
 }

mysqlx_error_t * get_error()
 {
if (message() || error_num())
returnthis;
returnNULL;
 }

} mysqlx_error_t;


structmysqlx_dyn_error_struct : publicmysqlx_error_struct
{
using mysqlx_error_struct::mysqlx_error_struct;
};

classMysqlx_diag : publicMysqlx_diag_base
{
protected:
 mysqlx_error_struct m_error;

public:
virtualvoidset_diagnostic(const Mysqlx_exception &ex)
 { m_error.set(ex); }

virtualvoidset_diagnostic(constchar *msg, unsignedint num)
 { m_error.set(msg, num); }

virtualvoidset_diagnostic(mysqlx_error_struct &&error)
 {
 m_error = std::move(error);
 }

voidclear()
 {
 m_error.reset();
 }

mysqlx_error_t * get_error()
 {
if (m_error.message() || m_error.error_num())
return &m_error;
returnNULL;
 }

};

#endif