blpapi_exception.h

Go to the documentation of this file.

/* Copyright 2012. Bloomberg Finance L.P.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), 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.
 */

 
#ifndef INCLUDED_BLPAPI_EXCEPTION
#define INCLUDED_BLPAPI_EXCEPTION

 
#include <blpapi_defs.h>
#include <blpapi_error.h>
 
#ifdef __cplusplus
extern "C" {
#endif


struct blpapi_ErrorInfo {
    int exceptionClass; 
    char description[256]; 
};
 
typedef struct blpapi_ErrorInfo blpapi_ErrorInfo_t;

BLPAPI_EXPORT
int blpapi_getErrorInfo(blpapi_ErrorInfo_t *buffer, int errorCode);

 
#ifdef __cplusplus
} // extern "C"
 
#include <exception>
#include <string>
 
namespace BloombergLP {
namespace blpapi {

class Exception : public std::exception {
 
    const std::string d_description;
 
  private:
    // NOT IMPLEMENTED
    Exception& operator=(const Exception&); // = delete
 
  public:
    // CREATORS
    explicit Exception(const std::string& description);
 
    // ACCESSORS
    const std::string& description() const throw();
 
    virtual const char *what() const throw();
 
    virtual ~Exception() throw();
};

class DuplicateCorrelationIdException : public Exception {
  public:
    // CREATORS
    explicit DuplicateCorrelationIdException(const std::string& description);
};

class InvalidStateException : public Exception {
  public:
    // CREATORS
    explicit InvalidStateException(const std::string& description);
};

class InvalidArgumentException : public Exception {
  public:
    // CREATORS
    explicit InvalidArgumentException(const std::string& description);
};

class InvalidConversionException : public Exception {
  public:
    // CREATORS
    explicit InvalidConversionException(const std::string& description);
};

class IndexOutOfRangeException : public Exception {
  public:
    // CREATORS
    explicit IndexOutOfRangeException(const std::string& description);
};

class FieldNotFoundException : public Exception {
  public:
    // CREATORS
    explicit FieldNotFoundException(const std::string& description);
};

class UnknownErrorException : public Exception {
  public:
    // CREATORS
    explicit UnknownErrorException(const std::string& description);
};

class UnsupportedOperationException : public Exception {
  public:
    // CREATORS
    explicit UnsupportedOperationException(const std::string& description);
};

class NotFoundException : public Exception {
  public:
    // CREATORS
    explicit NotFoundException(const std::string& description);
};

class ExceptionUtil {
 
  private:
    static void throwException(int errorCode);
 
  public:
    static void throwOnError(int errorCode);
};

 
// ============================================================================
//                        INLINE FUNCTION DEFINITIONS
// ============================================================================
 
// ---------------
// class Exception
// ---------------
 
inline Exception::Exception(const std::string& newDescription)
    : d_description(newDescription)
{
}
 
inline Exception::~Exception() throw() { }
 
inline const std::string& Exception::description() const throw()
{
    return d_description;
}
 
inline const char *Exception::what() const throw()
{
    return description().c_str();
}
 
// -------------------------------------
// class DuplicateCorrelationIdException
// -------------------------------------
 
inline DuplicateCorrelationIdException::DuplicateCorrelationIdException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// ---------------------------
// class InvalidStateException
// ---------------------------
 
inline InvalidStateException::InvalidStateException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// ------------------------------
// class InvalidArgumentException
// ------------------------------
 
inline InvalidArgumentException::InvalidArgumentException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// --------------------------------
// class InvalidConversionException
// --------------------------------
 
inline InvalidConversionException::InvalidConversionException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// ------------------------------
// class IndexOutOfRangeException
// ------------------------------
 
inline IndexOutOfRangeException::IndexOutOfRangeException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// ----------------------------
// class FieldNotFoundException
// ----------------------------
 
inline FieldNotFoundException::FieldNotFoundException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// ---------------------------
// class UnknownErrorException
// ---------------------------
 
inline UnknownErrorException::UnknownErrorException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// -----------------------------------
// class UnsupportedOperationException
// -----------------------------------
 
inline UnsupportedOperationException::UnsupportedOperationException(
        const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// -----------------------
// class NotFoundException
// -----------------------
 
inline NotFoundException::NotFoundException(const std::string& newDescription)
    : Exception(newDescription)
{
}
 
// -------------------
// class ExceptionUtil
// -------------------
 
inline void ExceptionUtil::throwException(int errorCode)
{
    const char *description = blpapi_getLastErrorDescription(errorCode);
    if (!description) {
        description = "Unknown";
    }
 
    if (BLPAPI_ERROR_DUPLICATE_CORRELATIONID == errorCode) {
        throw DuplicateCorrelationIdException(description);
    }
 
    switch (BLPAPI_RESULTCLASS(errorCode))
    case BLPAPI_INVALIDSTATE_CLASS: {
        throw InvalidStateException(description);
    case BLPAPI_INVALIDARG_CLASS:
        throw InvalidArgumentException(description);
    case BLPAPI_CNVERROR_CLASS:
        throw InvalidConversionException(description);
    case BLPAPI_BOUNDSERROR_CLASS:
        throw IndexOutOfRangeException(description);
    case BLPAPI_FLDNOTFOUND_CLASS:
        throw FieldNotFoundException(description);
    case BLPAPI_UNSUPPORTED_CLASS:
        throw UnsupportedOperationException(description);
    case BLPAPI_NOTFOUND_CLASS:
        throw NotFoundException(description);
    default:
        throw Exception(description);
    }
}
 
inline void ExceptionUtil::throwOnError(int errorCode)
{
    if (errorCode) {
        throwException(errorCode);
    }
}
 
} // close namespace blpapi {
} // close namespace BloombergLP {
 
#endif
 
#endif // #ifndef INCLUDED_BLPAPI_EXCEPTION