/*
*    Copyright (c) <2002-2009> <Jean-Philippe Barrette-LaPierre>
*    
*    Permission is hereby granted, free of charge, to any person obtaining
*    a copy of this software and associated documentation files 
*    (curlpp), to deal in the Software without restriction, 
*    including without limitation the rights to use, copy, modify, merge,
*    publish, distribute, sublicense, and/or sell copies of the Software,
*    and to permit persons to whom the Software is furnished to do so, 
*    subject to the following conditions:
*    
*    The above copyright notice and this permission notice shall be included
*    in all copies or substantial portions of the Software.
*    
*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
*    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
*    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
*    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
*    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
*    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include "curlpp/Exception.hpp"

curlpp::RuntimeError::~RuntimeError() throw()
{}

curlpp::RuntimeError::RuntimeError(const char * reason)
  : std::runtime_error(std::string(reason))
{}

curlpp::RuntimeError::RuntimeError(const std::string & reason)
  : std::runtime_error(reason)
{}

curlpp::LogicError::~LogicError() throw()
{}

curlpp::LogicError::LogicError(const char * reason)
    : std::logic_error(std::string(reason))
{}

curlpp::LogicError::LogicError(const std::string & reason)
    : std::logic_error(reason)
{}

curlpp::LibcurlRuntimeError::LibcurlRuntimeError(const std::string & reason, CURLcode code)
    : curlpp::RuntimeError(reason)
    , mCode(code)
{}

curlpp::LibcurlRuntimeError::LibcurlRuntimeError(const char * reason, CURLcode code)
    : curlpp::RuntimeError(reason)
    , mCode(code)
{}

CURLcode curlpp::LibcurlRuntimeError::whatCode() const throw()
{
   return mCode;
}

curlpp::LibcurlLogicError::LibcurlLogicError(const std::string & reason, CURLcode code)
    : curlpp::LogicError(reason)
    , mCode(code)
{}

curlpp::LibcurlLogicError::LibcurlLogicError(const char * reason, CURLcode code)
    : curlpp::LogicError(reason)
    , mCode(code)
{}

curlpp::UnsetOption::UnsetOption(const std::string & reason)
    : curlpp::RuntimeError(reason)
{}

curlpp::UnsetOption::UnsetOption(const char * reason)
    : curlpp::RuntimeError(reason)
{}

curlpp::NotAvailable::NotAvailable()
    : curlpp::LogicError("This option was not available at compile time.")
{}

curlpp::UnknowException::UnknowException() 
  : curlpp::RuntimeError("An unknown exception was thrown within a callback")
{}

CURLcode curlpp::LibcurlLogicError::whatCode() const throw()
{
   return mCode;
}

curlpp::CallbackExceptionBase::CallbackExceptionBase() 
  : RuntimeError("Exception thrown within a callback")
{}
    
curlpp::CallbackExceptionBase::CallbackExceptionBase(const CallbackExceptionBase & other) 
  : RuntimeError(other)
{}


void curlpp::libcurlRuntimeAssert(const std::string & reason, CURLcode code)
{
  curlpp::libcurlRuntimeAssert(reason.c_str(), code);
}

void curlpp::libcurlRuntimeAssert(const char * reason, CURLcode code)
{
  if (code != CURLE_OK)
    throw curlpp::LibcurlRuntimeError(reason, code);
}

void curlpp::libcurlLogicAssert(const std::string & reason, CURLcode code)
{
  libcurlLogicAssert(reason.c_str(), code);
}

void curlpp::libcurlLogicAssert(const char * reason, CURLcode code)
{
  if (code != CURLE_OK)
    throw curlpp::LibcurlLogicError(reason, code);
}

void curlpp::runtimeAssert(const std::string & reason, bool isOkay)
{
  runtimeAssert(reason.c_str(), isOkay);
}

void curlpp::runtimeAssert(const char * reason, bool isOkay)
{
  if (!isOkay)
    throw curlpp::RuntimeError(reason);
}

void curlpp::logicAssert(const std::string & reason, bool isOkay)
{
  logicAssert(reason.c_str(), isOkay);
}

void curlpp::logicAssert(const char * reason, bool isOkay)
{
   if (!isOkay)
     throw curlpp::LogicError(reason);
}

