Exception.hpp

/*
 * OCILIB - C Driver for Oracle (C Wrapper for Oracle OCI)
 *
 * Website: http://www.ocilib.net
 *
 * Copyright (c) 2007-2023 Vincent ROGIER <vince.rogier@ocilib.net>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include "ocilibcpp/types.hpp"
 
namespace ocilib
{
inline Exception::Exception() noexcept
    : _what(nullptr),
    _pStatement(nullptr),
    _pConnnection(nullptr),
    _row(0),
    _type(static_cast<ExceptionType::Type>(0)),
    _errLib(0),
    _errOracle(0)
{
 
}
 
inline Exception::Exception(OCI_Error *err) noexcept
    : _what(nullptr),
    _pStatement(OCI_ErrorGetStatement(err)),
    _pConnnection(OCI_ErrorGetConnection(err)),
    _row(OCI_ErrorGetRow(err)),
    _type(static_cast<ExceptionType::Type>(OCI_ErrorGetType(err))),
    _errLib(OCI_ErrorGetInternalCode(err)),
    _errOracle(OCI_ErrorGetOCICode(err))
{
    SetWhat(OCI_ErrorGetString(err));
}
 
inline Exception::Exception(const Exception& other) noexcept : Exception()
{
    *this = other;
}
 
inline Exception::~Exception() noexcept
{
    delete [] _what;
}
 
inline Exception& Exception::operator = (const Exception& other) noexcept
{
    if (this != &other)
    {
        _pStatement = other._pStatement;
        _pConnnection = other._pConnnection;
        _row = other._row;
        _type = other._type;
        _errLib = other._errLib;
        _errOracle = other._errOracle;
 
        CopyWhat(other._what);
    }
 
    return *this;
}
inline void Exception::CopyWhat(const char* value) noexcept
{
    if (_what)
    {
        delete[] _what;
        _what = nullptr;
    }
 
    if (!value)
    {
        return;
    }
 
    const size_t len = strlen(value) + 1;
 
    _what = new (std::nothrow) char[len];
    if (_what)
    {
        memcpy(_what, value, len);
    }
}
 
inline void Exception::SetWhat(const otext* value) noexcept
{
 
#if defined(OCI_CHARSET_ANSI)
 
    CopyWhat(value);
 
#else
 
    if (_what)
    {
        delete[] _what;
        _what = nullptr;
    }
 
    if (!value)
    {
        return;
    }
 
    const size_t valueLenght = wcslen(value);
 
    _what = new (std::nothrow) char[valueLenght + 1];
    if (_what)
    {
        const otext* ptr = value;
       
        mbstate_t mbs;
        mbrlen(nullptr, 0, &mbs);
    
    #if defined(_MSC_VER)
        __pragma(warning(disable : 4996))
    #endif
 
        const size_t convLenght = wcsrtombs(_what, &ptr, valueLenght, &mbs);
 
    #if defined(_MSC_VER)
        __pragma(warning(default: 4996))
    #endif   
            
        const size_t whatLenght = (static_cast<size_t>(-1) == convLenght) ? 0 : convLenght;
 
        _what[whatLenght] = 0;
 
 
    }
 
#endif
}
 
inline const char * Exception::what() const noexcept
{
    return _what;
}
 
inline ostring Exception::GetMessage() const
{
    const char* str = what();
 
    if (!str)
    {
        return ostring{};
    }
 
    ostring message;
 
#if defined(OCI_CHARSET_ANSI)
 
    message = str;
 
#else
 
    const size_t valueLenght = strlen(str);
 
    message.resize(valueLenght);
 
    const char* ptr = str;
 
    mbstate_t mbs;
    mbrlen(nullptr, 0, &mbs);
 
 
#if defined(_MSC_VER)
    __pragma(warning(disable : 4996))
#endif
 
    const size_t convLenght = mbsrtowcs(&message[0], &ptr, valueLenght, &mbs);
 
#if defined(_MSC_VER)
    __pragma(warning(default: 4996))
#endif 
 
    const size_t messLenght = (static_cast<size_t>(-1) == convLenght) ? 0 : convLenght;
 
    message.resize(messLenght);
 
#endif
 
    return message;
}
 
inline Exception::ExceptionType Exception::GetType() const
{
    return _type;
}
 
inline int Exception::GetOracleErrorCode() const
{
    return _errOracle;
}
 
inline int Exception::GetInternalErrorCode() const
{
    return _errLib;
}
 
inline Statement Exception::GetStatement() const
{
    return Statement(_pStatement, nullptr);
}
 
inline Connection Exception::GetConnection() const
{
    return Connection(_pConnnection, Environment::GetEnvironmentHandle());
}
 
inline unsigned int Exception::GetRow() const
{
    return _row;
}
 
}