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

#ifndef INCLUDED_BLPAPI_DEFS
#include <blpapi_defs.h>
#endif

#ifndef INCLUDED_BLPAPI_ERROR
#include <blpapi_error.h>
#endif

#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"

#ifndef INCLUDED_EXCEPTION
#include <exception>
#define INCLUDED_EXCEPTION
#endif

#ifndef INCLUDED_STRING
#include <string>
#define INCLUDED_STRING
#endif

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