blpapi_testutil.h

Go to the documentation of this file.

/* Copyright 2019. 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_TESTUTIL
#define INCLUDED_BLPAPI_TESTUTIL
 
#include <blpapi_correlationid.h>
#include <blpapi_datetime.h>
#include <blpapi_defs.h>
#include <blpapi_event.h>
#include <blpapi_messageformatter.h>
#include <blpapi_service.h>
#include <blpapi_streamproxy.h>
#include <blpapi_topic.h>
#include <blpapi_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
BLPAPI_EXPORT
int blpapi_TestUtil_createEvent(blpapi_Event_t **event, int eventType);
 
BLPAPI_EXPORT
int blpapi_TestUtil_deserializeService(
        const char *schema, size_t schemaLength, blpapi_Service_t **service);
 
BLPAPI_EXPORT
int blpapi_TestUtil_serializeService(blpapi_StreamWriter_t streamWriter,
        void *stream,
        const blpapi_Service_t *service);
 
BLPAPI_EXPORT
int blpapi_TestUtil_appendMessage(blpapi_MessageFormatter_t **formatter,
        blpapi_Event_t *event,
        const blpapi_SchemaElementDefinition_t *messageType,
        const blpapi_MessageProperties_t *properties);
 
BLPAPI_EXPORT
int blpapi_TestUtil_createTopic(
        blpapi_Topic_t **topic, const blpapi_Service_t *service, int isActive);
 
BLPAPI_EXPORT
int blpapi_TestUtil_getAdminMessageDefinition(
        blpapi_SchemaElementDefinition_t **definition,
        blpapi_Name_t *messageName);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_create(
        blpapi_MessageProperties_t **messageProperties);
 
BLPAPI_EXPORT
void blpapi_MessageProperties_destroy(
        blpapi_MessageProperties_t *messageProperties);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_copy(blpapi_MessageProperties_t **dest,
        const blpapi_MessageProperties_t *src);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_assign(blpapi_MessageProperties_t *lhs,
        const blpapi_MessageProperties_t *rhs);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_setCorrelationIds(
        blpapi_MessageProperties_t *messageProperties,
        const blpapi_CorrelationId_t *correlationIds,
        size_t numCorrelationIds);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_setRecapType(
        blpapi_MessageProperties_t *messageProperties,
        int recap,
        int fragment);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_setTimeReceived(
        blpapi_MessageProperties_t *messageProperties,
        const blpapi_HighPrecisionDatetime_t *timestamp);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_setService(
        blpapi_MessageProperties_t *messageProperties,
        const blpapi_Service_t *service);
 
BLPAPI_EXPORT
int blpapi_MessageProperties_setRequestId(
        blpapi_MessageProperties_t *messageProperties, const char *requestId);
 
#ifdef __cplusplus
} // extern "C"
 
#include <cassert>
#include <cstdio>
#include <fstream>
#include <vector>
 
namespace BloombergLP {
namespace blpapi {
namespace test {
 
// =======================
// class MessageProperties
// =======================
 
class MessageProperties {
 
  private:
    blpapi_MessageProperties_t *d_handle_p;
 
  public:
    // CREATORS
    MessageProperties();
    MessageProperties(const MessageProperties& original);
    ~MessageProperties();
    // MANIPULATORS
    MessageProperties& operator=(const MessageProperties& rhs);
    MessageProperties& setCorrelationIds(
            const blpapi_CorrelationId_t *correlationIds,
            size_t correlationIdCount);
    MessageProperties& setCorrelationIds(
            const std::vector<CorrelationId>& correlationIds);
    MessageProperties& setCorrelationId(const CorrelationId& correlationId);
    MessageProperties& setRecapType(Message::RecapType::Type recapType,
            Message::Fragment fragmentType = Message::FRAGMENT_NONE);
    MessageProperties& setTimeReceived(const Datetime& timeReceived);
    MessageProperties& setService(const Service& service);
    MessageProperties& setRequestId(const char *requestId);
    // ACCESSORS
    blpapi_MessageProperties_t *handle() const;
};
 
// ==============
// class TestUtil
// ==============
 
class TestUtil {
 
  public:
    // TYPES
 
    /*
     * \deprecated Following typedef is provided for backwards compatibility.
     * It will be removed in a future release.
     */
    typedef test::MessageProperties MessageProperties;
 
    // CLASS METHODS
    static Event createEvent(Event::EventType eventType);
    static MessageFormatter appendMessage(Event& event,
            const SchemaElementDefinition& elementDef,
            const MessageProperties& properties = MessageProperties());
    static Service deserializeService(std::istream& stream);
    static void serializeService(std::ostream& stream, const Service& service);
    static Topic createTopic(const Service& service, bool isActive = true);
    static SchemaElementDefinition getAdminMessageDefinition(
            const Name& messageName);
};
 
// ============================================================================
//                      INLINE FUNCTION DEFINITIONS
// ============================================================================
 
// --------------
// class TestUtil
// --------------
 
inline Event TestUtil::createEvent(Event::EventType eventType)
{
    blpapi_Event_t *event = 0;
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_TestUtil_createEvent)(&event, eventType));
    return Event(event);
}
 
inline Service TestUtil::deserializeService(std::istream& stream)
{
    blpapi_Service_t *buffer = 0;
 
    // This is a workaround for SunOS compiler not supporting construction from
    // 'std::istreambuf_iterator'.
    std::string schema;
    std::getline(stream, schema, '\0');
 
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_TestUtil_deserializeService)(
                    schema.c_str(), schema.length(), &buffer));
    return Service(buffer, Service::TestService());
}
 
inline void TestUtil::serializeService(
        std::ostream& stream, const Service& service)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_TestUtil_serializeService)(
            StreamProxyOstream::writeToStream, &stream, service.handle()));
}
 
inline MessageFormatter TestUtil::appendMessage(Event& event,
        const SchemaElementDefinition& elementDef,
        const MessageProperties& properties)
{
    blpapi_MessageFormatter_t *formatter = 0;
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_TestUtil_appendMessage)(
            &formatter, event.impl(), elementDef.impl(), properties.handle()));
 
    return MessageFormatter(formatter);
}
 
inline Topic TestUtil::createTopic(const Service& service, bool isActive)
{
    blpapi_Topic_t *topic = 0;
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_TestUtil_createTopic)(
            &topic, service.handle(), isActive));
    return Topic(topic);
}
 
inline SchemaElementDefinition TestUtil::getAdminMessageDefinition(
        const Name& messageName)
{
    blpapi_SchemaElementDefinition_t *definition = 0;
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_TestUtil_getAdminMessageDefinition)(
                    &definition, messageName.impl()));
    return SchemaElementDefinition(definition);
}
 
inline MessageProperties::MessageProperties()
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageProperties_create)(&d_handle_p));
}
 
inline MessageProperties::MessageProperties(const MessageProperties& original)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_MessageProperties_copy)(
            &d_handle_p, original.handle()));
}
 
inline MessageProperties& MessageProperties::operator=(
        const MessageProperties& rhs)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_MessageProperties_assign)(
            d_handle_p, rhs.handle()));
    return *this;
}
 
inline MessageProperties::~MessageProperties()
{
    BLPAPI_CALL_UNCHECKED(blpapi_MessageProperties_destroy)(d_handle_p);
}
 
inline blpapi_MessageProperties_t *MessageProperties::handle() const
{
    return d_handle_p;
}
 
inline MessageProperties& MessageProperties::setCorrelationId(
        const CorrelationId& cid)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageProperties_setCorrelationIds)(
                    d_handle_p, &cid.impl(), 1));
    return *this;
}
 
inline MessageProperties& MessageProperties::setCorrelationIds(
        const std::vector<CorrelationId>& cids)
{
    assert(!cids.empty());
 
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageProperties_setCorrelationIds)(
                    d_handle_p, &cids[0].impl(), cids.size()));
    return *this;
}
 
inline MessageProperties& MessageProperties::setCorrelationIds(
        const blpapi_CorrelationId_t *correlationIds,
        size_t correlationIdCount)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageProperties_setCorrelationIds)(
                    d_handle_p, correlationIds, correlationIdCount));
    return *this;
}
 
inline MessageProperties& MessageProperties::setRecapType(
        Message::RecapType::Type recapType, Message::Fragment fragmentType)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageProperties_setRecapType)(d_handle_p,
                    static_cast<int>(recapType),
                    static_cast<int>(fragmentType)));
    return *this;
}
 
inline MessageProperties& MessageProperties::setTimeReceived(
        const Datetime& timeReceived)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageProperties_setTimeReceived)(
                    d_handle_p, &timeReceived.rawHighPrecisionValue()));
    return *this;
}
 
inline MessageProperties& MessageProperties::setService(const Service& service)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageProperties_setService)(
                    d_handle_p, service.handle()));
    return *this;
}
 
inline MessageProperties& MessageProperties::setRequestId(
        const char *requestId)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageProperties_setRequestId)(d_handle_p, requestId));
    return *this;
}
 
} // close namespace test
 
// *Deprecated*
// Following typedef is provided for backwards compatibility.  It will be
// removed in a future release.
typedef test::TestUtil TestUtil;
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_TESTUTIL