blpapi_request.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_REQUEST
#define INCLUDED_BLPAPI_REQUEST

 
#include <blpapi_correlationid.h>
#include <blpapi_defs.h>
#include <blpapi_deprecate.h>
#include <blpapi_element.h>
#include <blpapi_exception.h>
#include <blpapi_name.h>
#include <blpapi_types.h>
 
struct blpapi_Request;
#ifdef __cplusplus
extern "C" {
#endif

typedef struct blpapi_Request blpapi_Request_t;


BLPAPI_EXPORT
void blpapi_Request_destroy(blpapi_Request_t *request);

BLPAPI_EXPORT
blpapi_Element_t *blpapi_Request_elements(blpapi_Request_t *request);

BLPAPI_EXPORT
void blpapi_Request_setPreferredRoute(
        blpapi_Request_t *request, blpapi_CorrelationId_t *correlationId);

BLPAPI_EXPORT
int blpapi_Request_getRequestId(
        const blpapi_Request_t *request, const char **requestId);

 
#ifdef __cplusplus
}
 
#include <cassert>
#include <cstddef>
#include <iosfwd>
#include <string>
 
namespace BloombergLP {
namespace blpapi {
 
class RequestRef;

class Request {
 
    blpapi_Request_t *d_handle;
    Element d_elements;

    Request& operator=(const Request& rhs);
 
  public:
    explicit Request(blpapi_Request_t *handle);
 
    Request(RequestRef src);
    Request(Request& src);
 
    ~Request();
 
    operator RequestRef();
 
    BLPAPI_DEPRECATE_STRING_NAME void set(const char *name, bool value);
 
    BLPAPI_DEPRECATE_STRING_NAME void set(const char *name, char value);
 
    BLPAPI_DEPRECATE_STRING_NAME void set(const char *name, Int32 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void set(const char *name, Int64 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void set(const char *name, Float32 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void set(const char *name, Float64 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void set(
            const char *name, const Datetime& value);
 
    BLPAPI_DEPRECATE_STRING_NAME void set(const char *name, const char *value);
 
    void set(const Name& name, bool value);
 
    void set(const Name& name, char value);
 
    void set(const Name& name, Int32 value);
 
    void set(const Name& name, Int64 value);
 
    void set(const Name& name, Float32 value);
 
    void set(const Name& name, Float64 value);
 
    void set(const Name& name, const Datetime& value);
 
    void set(const Name& name, const char *value);
 
    void set(const Name& name, const std::string& value);
 
    void set(const Name& name, const void *value, std::size_t length);
 
    template <typename BYTES,
            typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type
            = true>
    void set(const Name& name, const BYTES& value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(const char *name, bool value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(const char *name, char value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(const char *name, Int32 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(const char *name, Int64 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(const char *name, Float32 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(const char *name, Float64 value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(
            const char *name, const Datetime& value);
 
    BLPAPI_DEPRECATE_STRING_NAME void append(
            const char *name, const char *value);
 
    void append(const Name& name, bool value);
 
    void append(const Name& name, char value);
 
    void append(const Name& name, Int32 value);
 
    void append(const Name& name, Int64 value);
 
    void append(const Name& name, Float32 value);
 
    void append(const Name& name, Float64 value);
 
    void append(const Name& name, const Datetime& value);
 
    void append(const Name& name, const char *value);
 
    void append(const Name& name, const std::string& value);
 
    Element asElement();
 
    BLPAPI_DEPRECATE_STRING_NAME Element getElement(const char *name);
 
    Element getElement(const Name& name);
 
    BLPAPI_DEPRECATE_STRING_NAME const Element getElement(
            const char *name) const;
 
    const Element getElement(const Name& name) const;
 
    const Element asElement() const;
 
    void fromJson(const char *json);
 
    void fromJson(const std::string& json);
 
    const char *getRequestId() const;

    blpapi_Request_t *handle() const;
 
    std::ostream& print(
            std::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
};

 
std::ostream& operator<<(std::ostream& stream, const Request& request);


class RequestRef {
    Request *d_request_p;
 
  public:
    RequestRef(Request *request_p);
 
    Request *ptr() const;
 
    Request *operator->() const;
};

 
//=============================================================================
//                           INLINE FUNCTION DEFINITIONS
//=============================================================================
 
// -------------
// class Request
// -------------
 
inline Request::Request(blpapi_Request_t *newHandle)
{
    d_handle = newHandle;
    if (newHandle) {
        d_elements.rebind(blpapi_Request_elements(newHandle));
    }
}
 
inline Request::Request(RequestRef ref)
{
    Request *src = ref.ptr();
    assert(src);
    d_handle = src->d_handle;
    d_elements = src->d_elements;
    src->d_handle = 0;
    src->d_elements.rebind(0);
}
 
inline Request::Request(Request& src)
{
    d_handle = src.d_handle;
    d_elements = src.d_elements;
    src.d_handle = 0;
    src.d_elements.rebind(0);
}
 
inline Request::~Request()
{
    if (d_handle) {
        blpapi_Request_destroy(d_handle);
    }
}
 
inline Request::operator RequestRef() { return RequestRef(this); }
 
inline void Request::set(const char *element, bool value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::set(const char *element, char value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::set(const char *element, Int32 value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::set(const char *element, Int64 value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::set(const char *element, Float32 value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::set(const char *element, Float64 value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::set(const char *element, const Datetime& value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::set(const char *element, const char *value)
{
    d_elements.setElement(Name(element), value);
}
 
inline void Request::append(const char *element, bool value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::append(const char *element, char value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::append(const char *element, Int32 value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::append(const char *element, Int64 value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::append(const char *element, Float32 value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::append(const char *element, Float64 value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::append(const char *element, const Datetime& value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::append(const char *element, const char *value)
{
    Element namedElement = d_elements.getElement(Name(element));
    namedElement.appendValue(value);
}
 
inline void Request::set(const Name& element, bool value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, char value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, Int32 value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, Int64 value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, Float32 value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, Float64 value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, const Datetime& value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, const char *value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(const Name& element, const std::string& value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::set(
        const Name& element, const void *value, std::size_t length)
{
    d_elements.setElement(element, value, length);
}
 
template <typename BYTES,
        typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type>
inline void Request::set(const Name& element, const BYTES& value)
{
    d_elements.setElement(element, value);
}
 
inline void Request::append(const Name& element, bool value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, char value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, Int32 value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, Int64 value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, Float32 value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, Float64 value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, const Datetime& value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, const char *value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline void Request::append(const Name& element, const std::string& value)
{
    Element namedElement = d_elements.getElement(element);
    namedElement.appendValue(value);
}
 
inline Element Request::getElement(const char *name)
{
    return d_elements.getElement(Name(name));
}
 
inline Element Request::getElement(const Name& name)
{
    return d_elements.getElement(name);
}
 
inline Element Request::asElement() { return d_elements; }
 
inline const Element Request::getElement(const char *name) const
{
    return d_elements.getElement(Name(name));
}
 
inline const Element Request::getElement(const Name& name) const
{
    return d_elements.getElement(name);
}
 
inline const Element Request::asElement() const { return d_elements; }
 
inline void Request::fromJson(const char *json) { d_elements.fromJson(json); }
 
inline void Request::fromJson(const std::string& json)
{
    fromJson(json.c_str());
}
 
inline const char *Request::getRequestId() const
{
    const char *requestId = 0;
    BLPAPI_CALL(blpapi_Request_getRequestId)(d_handle, &requestId);
    return requestId;
}

inline blpapi_Request_t *Request::handle() const { return d_handle; }
 
inline std::ostream& Request::print(
        std::ostream& stream, int level, int spacesPerLevel) const
{
    return d_elements.print(stream, level, spacesPerLevel);
}
 
inline std::ostream& operator<<(std::ostream& stream, const Request& request)
{
    return request.print(stream, 0, -1);
}
// ----------------
// class RequestRef
// ----------------
 
inline RequestRef::RequestRef(Request *request)
    : d_request_p(request)
{
}
 
inline Request *RequestRef::ptr() const { return this->d_request_p; }
 
inline Request *RequestRef::operator->() const { return this->d_request_p; }
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
 
#endif // #ifndef INCLUDED_BLPAPI_REQUEST