blpapi_element.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_ELEMENT
#define INCLUDED_BLPAPI_ELEMENT

#include <blpapi_call.h>
#include <blpapi_datetime.h>
#include <blpapi_defs.h>
#include <blpapi_name.h>
#include <blpapi_schema.h>
#include <blpapi_streamproxy.h>
#include <blpapi_types.h>

#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

BLPAPI_EXPORT blpapi_Name_t *blpapi_Element_name(
        const blpapi_Element_t *element);

BLPAPI_EXPORT const char *blpapi_Element_nameString(
        const blpapi_Element_t *element);

BLPAPI_EXPORT blpapi_SchemaElementDefinition_t *blpapi_Element_definition(
        const blpapi_Element_t *element);

BLPAPI_EXPORT int blpapi_Element_datatype(const blpapi_Element_t *element);

BLPAPI_EXPORT int blpapi_Element_isComplexType(
        const blpapi_Element_t *element);

BLPAPI_EXPORT int blpapi_Element_isArray(const blpapi_Element_t *element);

BLPAPI_EXPORT int blpapi_Element_isReadOnly(const blpapi_Element_t *element);

BLPAPI_EXPORT size_t blpapi_Element_numValues(const blpapi_Element_t *element);

BLPAPI_EXPORT size_t blpapi_Element_numElements(
        const blpapi_Element_t *element);

BLPAPI_EXPORT int blpapi_Element_isNullValue(
        const blpapi_Element_t *element, size_t position);

BLPAPI_EXPORT int blpapi_Element_isNull(const blpapi_Element_t *element);

BLPAPI_EXPORT int blpapi_Element_print(const blpapi_Element_t *element,
        blpapi_StreamWriter_t streamWriter,
        void *stream,
        int level,
        int spacesPerLevel);

BLPAPI_EXPORT
int blpapi_Element_getElementAt(const blpapi_Element_t *element,
        blpapi_Element_t **result,
        size_t position);

BLPAPI_EXPORT
int blpapi_Element_getElement(const blpapi_Element_t *element,
        blpapi_Element_t **result,
        const char *nameString,
        const blpapi_Name_t *name);

BLPAPI_EXPORT
int blpapi_Element_hasElement(const blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name);

BLPAPI_EXPORT
int blpapi_Element_hasElementEx(const blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        int excludeNullElements,
        int reserved);

BLPAPI_EXPORT
int blpapi_Element_getValueAsBool(
        const blpapi_Element_t *element, blpapi_Bool_t *buffer, size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsChar(
        const blpapi_Element_t *element, blpapi_Char_t *buffer, size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsInt32(
        const blpapi_Element_t *element, blpapi_Int32_t *buffer, size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsInt64(
        const blpapi_Element_t *element, blpapi_Int64_t *buffer, size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsFloat32(const blpapi_Element_t *element,
        blpapi_Float32_t *buffer,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsFloat64(const blpapi_Element_t *element,
        blpapi_Float64_t *buffer,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsString(
        const blpapi_Element_t *element, const char **buffer, size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsDatetime(const blpapi_Element_t *element,
        blpapi_Datetime_t *buffer,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsHighPrecisionDatetime(
        const blpapi_Element_t *element,
        blpapi_HighPrecisionDatetime_t *buffer,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsElement(const blpapi_Element_t *element,
        blpapi_Element_t **buffer,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsName(
        const blpapi_Element_t *element, blpapi_Name_t **buffer, size_t index);

BLPAPI_EXPORT
int blpapi_Element_getValueAsBytes(const blpapi_Element_t *element,
        const char **buffer,
        size_t *length,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_getChoice(
        const blpapi_Element_t *element, blpapi_Element_t **result);

BLPAPI_EXPORT
int blpapi_Element_setValueBool(
        blpapi_Element_t *element, blpapi_Bool_t value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueChar(
        blpapi_Element_t *element, blpapi_Char_t value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueInt32(
        blpapi_Element_t *element, blpapi_Int32_t value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueInt64(
        blpapi_Element_t *element, blpapi_Int64_t value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueFloat32(
        blpapi_Element_t *element, blpapi_Float32_t value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueFloat64(
        blpapi_Element_t *element, blpapi_Float64_t value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueString(
        blpapi_Element_t *element, const char *value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueDatetime(blpapi_Element_t *element,
        const blpapi_Datetime_t *value,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueHighPrecisionDatetime(blpapi_Element_t *element,
        const blpapi_HighPrecisionDatetime_t *value,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueBytes(blpapi_Element_t *element,
        const char *value,
        size_t length,
        size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueFromElement(
        blpapi_Element_t *element, blpapi_Element_t *value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setValueFromName(
        blpapi_Element_t *element, const blpapi_Name_t *value, size_t index);

BLPAPI_EXPORT
int blpapi_Element_setElementBool(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        blpapi_Bool_t value);

BLPAPI_EXPORT
int blpapi_Element_setElementChar(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        blpapi_Char_t value);

BLPAPI_EXPORT
int blpapi_Element_setElementInt32(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        blpapi_Int32_t value);

BLPAPI_EXPORT
int blpapi_Element_setElementInt64(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        blpapi_Int64_t value);

BLPAPI_EXPORT
int blpapi_Element_setElementFloat32(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        blpapi_Float32_t value);

BLPAPI_EXPORT
int blpapi_Element_setElementFloat64(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        blpapi_Float64_t value);

BLPAPI_EXPORT
int blpapi_Element_setElementString(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        const char *value);

BLPAPI_EXPORT
int blpapi_Element_setElementDatetime(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        const blpapi_Datetime_t *value);

BLPAPI_EXPORT
int blpapi_Element_setElementHighPrecisionDatetime(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        const blpapi_HighPrecisionDatetime_t *value);

BLPAPI_EXPORT
int blpapi_Element_setElementBytes(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        const char *value,
        size_t length);

BLPAPI_EXPORT
int blpapi_Element_setElementFromField(blpapi_Element_t *element,
        const char *nameString,
        const blpapi_Name_t *name,
        blpapi_Element_t *sourcebuffer);

BLPAPI_EXPORT
int blpapi_Element_setElementFromName(blpapi_Element_t *element,
        const char *elementName,
        const blpapi_Name_t *name,
        const blpapi_Name_t *buffer);

BLPAPI_EXPORT
int blpapi_Element_appendElement(
        blpapi_Element_t *element, blpapi_Element_t **appendedElement);

BLPAPI_EXPORT
int blpapi_Element_setChoice(blpapi_Element_t *element,
        blpapi_Element_t **resultElement,
        const char *nameCstr,
        const blpapi_Name_t *name,
        size_t index);

#ifdef __cplusplus
}

#include <blpapi_exception.h>

#include <cassert>
#include <string>
#include <type_traits>

namespace BloombergLP {
namespace blpapi {

class Element {

    blpapi_Element_t *d_handle_p;

  public:
    Element();
    explicit Element(blpapi_Element_t *element);

    // MANIPULATORS

    void rebind(blpapi_Element_t *element);

    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, bool value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, char value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, Int32 value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, Int64 value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, Float32 value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, Float64 value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, const Datetime& value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, const char *value);
    [[deprecated("Use the form that takes Name instead of const char*")]] void
    setElement(const char *name, const Name& value);
    void setElement(const Name& name, bool value);
    void setElement(const Name& name, char value);
    void setElement(const Name& name, Int32 value);
    void setElement(const Name& name, Int64 value);
    void setElement(const Name& name, Float32 value);
    void setElement(const Name& name, Float64 value);
    void setElement(const Name& name, const Datetime& value);
    void setElement(const Name& name, const char *value);
    void setElement(const Name& name, const std::string& value);
    void setElement(const Name& name, const Name& value);
    void setElement(const Name& name, const void *value, size_t length);
    template <typename BYTES,
            typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type
            = true>
    void setElement(const Name& name, const BYTES& value);
    void setValue(bool value, size_t index = 0);
    void setValue(char value, size_t index = 0);
    void setValue(Int32 value, size_t index = 0);
    void setValue(Int64 value, size_t index = 0);
    void setValue(Float32 value, size_t index = 0);
    void setValue(Float64 value, size_t index = 0);
    void setValue(const Datetime& value, size_t index = 0);
    void setValue(const char *value, size_t index = 0);
    void setValue(const std::string& value, size_t index = 0);
    void setValue(const Name& valueName, size_t index = 0);
    void setValue(const void *value, size_t length, size_t index);
    template <typename BYTES,
            typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type
            = true>
    void setValue(const BYTES& value, size_t index = 0);
    void appendValue(bool value);
    void appendValue(char value);
    void appendValue(Int32 value);
    void appendValue(Int64 value);
    void appendValue(Float32 value);
    void appendValue(Float64 value);
    void appendValue(const Datetime& value);
    void appendValue(const char *value);
    void appendValue(const std::string& value);
    void appendValue(const Name& value);
    Element appendElement();
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Element
    setChoice(const char *selectionName);
    Element setChoice(const Name& selectionName);
    blpapi_Element_t *handle();

    // ACCESSORS

    Name name() const;
    int datatype() const;
    bool isComplexType() const;
    bool isArray() const;
    bool isNull() const;
    bool isReadOnly() const;
    SchemaElementDefinition elementDefinition() const;
    size_t numValues() const;
    size_t numElements() const;
    bool isValid() const;
    bool isNullValue(size_t position = 0) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] bool
    hasElement(const char *name, bool excludeNullElements = false) const;
    bool hasElement(const Name& name, bool excludeNullElements = false) const;
    int getValueAs(bool *result, size_t index = 0) const;
    int getValueAs(char *result, size_t index = 0) const;
    int getValueAs(Int32 *result, size_t index = 0) const;
    int getValueAs(Int64 *result, size_t index = 0) const;
    int getValueAs(Float32 *result, size_t index = 0) const;
    int getValueAs(Float64 *result, size_t index = 0) const;
    int getValueAs(Datetime *result, size_t index = 0) const;
    int getValueAs(std::string *result, size_t index = 0) const;
    int getValueAs(Bytes *result, size_t index = 0) const;
    int getValueAs(Element *result, size_t index = 0) const;
    int getValueAs(Name *result, size_t index = 0) const;
    bool getValueAsBool(size_t index = 0) const;
    char getValueAsChar(size_t index = 0) const;
    Int32 getValueAsInt32(size_t index = 0) const;
    Int64 getValueAsInt64(size_t index = 0) const;
    Float32 getValueAsFloat32(size_t index = 0) const;
    Float64 getValueAsFloat64(size_t index = 0) const;
    Datetime getValueAsDatetime(size_t index = 0) const;
    const char *getValueAsString(size_t index = 0) const;
    Bytes getValueAsBytes(size_t index = 0) const;
    Element getValueAsElement(size_t index = 0) const;
    Name getValueAsName(size_t index = 0) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] int
    getElement(Element *result, const char *name) const;
    int getElement(Element *result, const Name& name) const;
    int getElement(Element *result, size_t position) const;
    Element getElement(size_t position) const;
    Element getElement(const Name& name) const;
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Element
    getElement(const char *name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] bool
    getElementAsBool(const char *name) const;
    bool getElementAsBool(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] char
    getElementAsChar(const char *name) const;
    char getElementAsChar(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] Int32
    getElementAsInt32(const char *name) const;
    Int32 getElementAsInt32(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] Int64
    getElementAsInt64(const char *name) const;
    Int64 getElementAsInt64(const Name& name) const;
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Float32
    getElementAsFloat32(const char *name) const;
    Float32 getElementAsFloat32(const Name& name) const;
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Float64
    getElementAsFloat64(const char *name) const;
    Float64 getElementAsFloat64(const Name& name) const;
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Datetime
    getElementAsDatetime(const char *name) const;
    Datetime getElementAsDatetime(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const "
                 "char*")]] const char *
    getElementAsString(const char *name) const;
    const char *getElementAsString(const Name& name) const;
    Bytes getElementAsBytes(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] Name
    getElementAsName(const char *name) const;
    Name getElementAsName(const Name& name) const;
    Element getChoice() const;
    const blpapi_Element_t *handle() const;

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

// FREE OPERATORS
std::ostream& operator<<(std::ostream& stream, const Element& element);
// ============================================================================
//                      INLINE AND TEMPLATE FUNCTION IMPLEMENTATIONS
// ============================================================================

// -------------
// class Element
// -------------

inline Element::Element()
    : d_handle_p(0)
{
}

inline Element::Element(blpapi_Element_t *newHandle)
    : d_handle_p(newHandle)
{
}

inline void Element::rebind(blpapi_Element_t *element)
{
    d_handle_p = element;
}

inline void Element::setElement(const char *elementName, bool value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementBool(
            d_handle_p, elementName, 0, value ? 1 : 0));
}

inline void Element::setElement(const char *elementName, char value)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setElementChar(d_handle_p, elementName, 0, value));
}

inline void Element::setElement(const char *elementName, Int32 value)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setElementInt32(d_handle_p, elementName, 0, value));
}

inline void Element::setElement(const char *elementName, Int64 value)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setElementInt64(d_handle_p, elementName, 0, value));
}

inline void Element::setElement(const char *elementName, Float32 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementFloat32(
            d_handle_p, elementName, 0, value));
}

inline void Element::setElement(const char *elementName, Float64 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementFloat64(
            d_handle_p, elementName, 0, value));
}

inline void Element::setElement(const char *elementName, const Datetime& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_ELEMENT_SETELEMENTHIGHPRECISIONDATETIME(d_handle_p,
                    elementName,
                    0,
                    &value.rawHighPrecisionValue()));
}

inline void Element::setElement(const char *elementName, const char *value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementString(
            d_handle_p, elementName, 0, value));
}

inline void Element::setElement(const char *elementName, const Name& value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementFromName(
            d_handle_p, elementName, 0, value.impl()));
}

inline void Element::setElement(const Name& elementName, bool value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementBool(
            d_handle_p, 0, elementName.impl(), value ? 1 : 0));
}

inline void Element::setElement(const Name& elementName, char value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementChar(
            d_handle_p, 0, elementName.impl(), value));
}

inline void Element::setElement(const Name& elementName, Int32 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementInt32(
            d_handle_p, 0, elementName.impl(), value));
}

inline void Element::setElement(const Name& elementName, Int64 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementInt64(
            d_handle_p, 0, elementName.impl(), value));
}

inline void Element::setElement(const Name& elementName, Float32 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementFloat32(
            d_handle_p, 0, elementName.impl(), value));
}

inline void Element::setElement(const Name& elementName, Float64 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementFloat64(
            d_handle_p, 0, elementName.impl(), value));
}

inline void Element::setElement(const Name& elementName, const Datetime& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_ELEMENT_SETELEMENTHIGHPRECISIONDATETIME(d_handle_p,
                    0,
                    elementName.impl(),
                    &value.rawHighPrecisionValue()));
}

inline void Element::setElement(const Name& elementName, const char *value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementString(
            d_handle_p, 0, elementName.impl(), value));
}

inline void Element::setElement(
        const Name& elementName, const std::string& value)
{
    setElement(elementName, value.c_str());
}

inline void Element::setElement(const Name& elementName, const Name& value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setElementFromName(
            d_handle_p, 0, elementName.impl(), value.impl()));
}

inline void Element::setElement(
        const Name& elementName, const void *value, size_t length)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_Element_setElementBytes)(d_handle_p,
                    0,
                    elementName.impl(),
                    reinterpret_cast<const char *>(value),
                    length));
}

template <typename BYTES,
        typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type>
inline void Element::setElement(const Name& elementName, const BYTES& value)
{
    setElement(elementName, value.data(), value.size());
}

inline void Element::setValue(bool value, size_t index)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setValueBool(d_handle_p, value, index));
}

inline void Element::setValue(char value, size_t index)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setValueChar(d_handle_p, value, index));
}

inline void Element::setValue(Int32 value, size_t index)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setValueInt32(d_handle_p, value, index));
}

inline void Element::setValue(Int64 value, size_t index)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setValueInt64(d_handle_p, value, index));
}

inline void Element::setValue(Float32 value, size_t index)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setValueFloat32(d_handle_p, value, index));
}

inline void Element::setValue(Float64 value, size_t index)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setValueFloat64(d_handle_p, value, index));
}

inline void Element::setValue(const Datetime& value, size_t index)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_ELEMENT_SETVALUEHIGHPRECISIONDATETIME(
                    d_handle_p, &value.rawHighPrecisionValue(), index));
}

inline void Element::setValue(const char *value, size_t index)
{
    ExceptionUtil::throwOnError(
            blpapi_Element_setValueString(d_handle_p, value, index));
}

inline void Element::setValue(const std::string& value, size_t index)
{
    setValue(value.c_str(), index);
}

inline void Element::setValue(const Name& valueName, size_t index)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueFromName(
            d_handle_p, valueName.impl(), index));
}

inline void Element::setValue(const void *value, size_t length, size_t index)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_Element_setValueBytes)(
            d_handle_p, reinterpret_cast<const char *>(value), length, index));
}

template <typename BYTES,
        typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type>
inline void Element::setValue(const BYTES& value, size_t index)
{
    setValue(value.data(), value.size(), index);
}

inline void Element::appendValue(bool value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueBool(
            d_handle_p, value, BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(char value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueChar(
            d_handle_p, value, BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(Int32 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueInt32(
            d_handle_p, value, BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(Int64 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueInt64(
            d_handle_p, value, BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(Float32 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueFloat32(
            d_handle_p, value, BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(Float64 value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueFloat64(
            d_handle_p, value, BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(const Datetime& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_ELEMENT_SETVALUEHIGHPRECISIONDATETIME(d_handle_p,
                    &value.rawHighPrecisionValue(),
                    BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(const char *value)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueString(
            d_handle_p, value, BLPAPI_ELEMENT_INDEX_END));
}

inline void Element::appendValue(const std::string& value)
{
    appendValue(value.c_str());
}

inline void Element::appendValue(const Name& valueName)
{
    ExceptionUtil::throwOnError(blpapi_Element_setValueFromName(
            d_handle_p, valueName.impl(), BLPAPI_ELEMENT_INDEX_END));
}

inline Element Element::appendElement()
{
    blpapi_Element_t *appendedElement = 0;
    ExceptionUtil::throwOnError(
            blpapi_Element_appendElement(d_handle_p, &appendedElement));
    return Element(appendedElement);
}

inline Element Element::setChoice(const char *selectionName)
{
    blpapi_Element_t *resultElement = 0;
    ExceptionUtil::throwOnError(blpapi_Element_setChoice(
            d_handle_p, &resultElement, selectionName, 0, 0));
    return Element(resultElement);
}

inline Element Element::setChoice(const Name& selectionName)
{
    blpapi_Element_t *resultElement = 0;
    ExceptionUtil::throwOnError(blpapi_Element_setChoice(
            d_handle_p, &resultElement, 0, selectionName.impl(), 0));
    return Element(resultElement);
}

inline blpapi_Element_t *Element::handle() { return d_handle_p; }

inline Name Element::name() const
{
    return Name(blpapi_Element_name(d_handle_p));
}

inline int Element::getElement(Element *element, const char *nameString) const
{
    assert(element);

    blpapi_Element_t *fldt = 0;
    int rc = blpapi_Element_getElement(d_handle_p, &fldt, nameString, 0);
    if (!rc) {
        element->rebind(fldt);
    }

    return rc;
}

inline int Element::getElement(Element *element, const Name& elementName) const
{
    assert(element);

    blpapi_Element_t *fldt = 0;
    int rc = blpapi_Element_getElement(
            d_handle_p, &fldt, 0, elementName.impl());
    if (!rc) {
        element->rebind(fldt);
    }

    return rc;
}

inline int Element::getElement(Element *element, size_t position) const
{
    assert(element);

    blpapi_Element_t *fldt = 0;
    int rc = blpapi_Element_getElementAt(d_handle_p, &fldt, position);
    if (!rc) {
        element->rebind(fldt);
    }

    return rc;
}

inline int Element::datatype() const
{
    return blpapi_Element_datatype(d_handle_p);
}

inline bool Element::isComplexType() const
{
    return blpapi_Element_isComplexType(d_handle_p) ? true : false;
}

inline bool Element::isArray() const
{
    return blpapi_Element_isArray(d_handle_p) ? true : false;
}

inline bool Element::isNull() const
{
    return blpapi_Element_isNull(d_handle_p) ? true : false;
}

inline bool Element::isReadOnly() const
{
    return blpapi_Element_isReadOnly(d_handle_p) ? true : false;
}

inline SchemaElementDefinition Element::elementDefinition() const
{
    return SchemaElementDefinition(blpapi_Element_definition(d_handle_p));
}

inline size_t Element::numValues() const
{
    return blpapi_Element_numValues(d_handle_p);
}

inline size_t Element::numElements() const
{
    return blpapi_Element_numElements(d_handle_p);
}

inline bool Element::isValid() const { return d_handle_p ? true : false; }

inline bool Element::isNullValue(size_t position) const
{
    int rc = blpapi_Element_isNullValue(d_handle_p, position);
    if (rc != 0 && rc != 1) {
        ExceptionUtil::throwOnError(rc);
    }
    return rc ? true : false;
}

inline bool Element::hasElement(
        const char *nameString, bool excludeNullElements) const
{
    if (excludeNullElements) {
        return (blpapi_Element_hasElementEx(
                        d_handle_p, nameString, 0, excludeNullElements, 0)
                        ? true
                        : false);
    }
    return blpapi_Element_hasElement(d_handle_p, nameString, 0) ? true : false;
}

inline bool Element::hasElement(
        const Name& elementName, bool excludeNullElements) const
{
    if (excludeNullElements) {
        return (blpapi_Element_hasElementEx(d_handle_p,
                        0,
                        elementName.impl(),
                        excludeNullElements,
                        0)
                        ? true
                        : false);
    }
    return blpapi_Element_hasElement(d_handle_p, 0, elementName.impl())
            ? true
            : false;
}

inline Element Element::getElement(const Name& elementName) const
{
    blpapi_Element_t *fldt = 0;
    ExceptionUtil::throwOnError(blpapi_Element_getElement(
            d_handle_p, &fldt, 0, elementName.impl()));
    return Element(fldt);
}

inline Element Element::getElement(const char *elementName) const
{
    blpapi_Element_t *fldt = 0;
    ExceptionUtil::throwOnError(
            blpapi_Element_getElement(d_handle_p, &fldt, elementName, 0));
    return Element(fldt);
}

inline Element Element::getElement(size_t position) const
{
    blpapi_Element_t *element = 0;
    ExceptionUtil::throwOnError(
            blpapi_Element_getElementAt(d_handle_p, &element, position));
    return Element(element);
}

inline int Element::getValueAs(bool *buffer, size_t index) const
{
    assert(buffer);

    blpapi_Bool_t tmp = false;

    int res = blpapi_Element_getValueAsBool(d_handle_p, &tmp, index);
    *buffer = tmp ? true : false;
    return res;
}

inline int Element::getValueAs(char *buffer, size_t index) const
{
    return blpapi_Element_getValueAsChar(d_handle_p, buffer, index);
}

inline int Element::getValueAs(Int32 *buffer, size_t index) const
{
    return blpapi_Element_getValueAsInt32(d_handle_p, buffer, index);
}

inline int Element::getValueAs(Int64 *buffer, size_t index) const
{
    return blpapi_Element_getValueAsInt64(d_handle_p, buffer, index);
}

inline int Element::getValueAs(Float32 *buffer, size_t index) const
{
    return blpapi_Element_getValueAsFloat32(d_handle_p, buffer, index);
}

inline int Element::getValueAs(Float64 *buffer, size_t index) const
{
    return blpapi_Element_getValueAsFloat64(d_handle_p, buffer, index);
}

inline int Element::getValueAs(Datetime *buffer, size_t index) const
{
    BLPAPI_CALL_ELEMENT_GETVALUEASHIGHPRECISIONDATETIME(
            d_handle_p, buffer, index);
}

inline int Element::getValueAs(std::string *result, size_t index) const
{
    assert(result);

    const char *buffer = 0;
    int rc = blpapi_Element_getValueAsString(d_handle_p, &buffer, index);
    if (!rc) {
        *result = buffer;
    }
    return rc;
}

inline int Element::getValueAs(Bytes *result, size_t index) const
{
    assert(result);

    const char *buffer = 0;
    size_t length = 0;
    const int rc = BLPAPI_CALL(blpapi_Element_getValueAsBytes)(
            d_handle_p, &buffer, &length, index);
    if (!rc) {
        result->assign(buffer, length);
    }
    return rc;
}

inline int Element::getValueAs(Element *buffer, size_t index) const
{
    assert(buffer);

    return blpapi_Element_getValueAsElement(
            d_handle_p, &buffer->d_handle_p, index);
}

inline int Element::getValueAs(Name *buffer, size_t index) const
{
    assert(buffer);

    blpapi_Name_t *tmpName = 0;
    int res = blpapi_Element_getValueAsName(d_handle_p, &tmpName, index);
    if (!res) {
        *buffer = Name(tmpName);
    }
    return res;
}

inline bool Element::getValueAsBool(size_t index) const
{
    bool value = false;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline char Element::getValueAsChar(size_t index) const
{
    char value = 0;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline Int32 Element::getValueAsInt32(size_t index) const
{
    Int32 value = 0;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline Int64 Element::getValueAsInt64(size_t index) const
{
    Int64 value = 0;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline Float32 Element::getValueAsFloat32(size_t index) const
{
    Float32 value = 0.0;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline Float64 Element::getValueAsFloat64(size_t index) const
{
    Float64 value = 0.0;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline Datetime Element::getValueAsDatetime(size_t index) const
{
    Datetime value;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline const char *Element::getValueAsString(size_t index) const
{
    const char *tmpStringBuffer = 0;
    ExceptionUtil::throwOnError(blpapi_Element_getValueAsString(
            d_handle_p, &tmpStringBuffer, index));
    return tmpStringBuffer;
}

inline Bytes Element::getValueAsBytes(size_t index) const
{
    Bytes value;
    ExceptionUtil::throwOnError(getValueAs(&value, index));
    return value;
}

inline Element Element::getValueAsElement(size_t index) const
{
    blpapi_Element_t *element = 0;
    ExceptionUtil::throwOnError(
            blpapi_Element_getValueAsElement(d_handle_p, &element, index));
    return Element(element);
}

inline Name Element::getValueAsName(size_t index) const
{
    blpapi_Name_t *nameValue = 0;
    ExceptionUtil::throwOnError(
            blpapi_Element_getValueAsName(d_handle_p, &nameValue, index));
    return Name(nameValue);
}

inline Element Element::getChoice() const
{
    blpapi_Element_t *element = 0;
    ExceptionUtil::throwOnError(
            blpapi_Element_getChoice(d_handle_p, &element));
    return Element(element);
}

inline bool Element::getElementAsBool(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsBool();
}

inline bool Element::getElementAsBool(const Name& elementName) const
{
    return getElement(elementName).getValueAsBool();
}

inline char Element::getElementAsChar(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsChar();
}

inline char Element::getElementAsChar(const Name& elementName) const
{
    return getElement(elementName).getValueAsChar();
}

inline Int32 Element::getElementAsInt32(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsInt32();
}

inline Int32 Element::getElementAsInt32(const Name& elementName) const
{
    return getElement(elementName).getValueAsInt32();
}

inline Int64 Element::getElementAsInt64(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsInt64();
}

inline Int64 Element::getElementAsInt64(const Name& elementName) const
{
    return getElement(elementName).getValueAsInt64();
}

inline Float32 Element::getElementAsFloat32(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsFloat32();
}

inline Float32 Element::getElementAsFloat32(const Name& elementName) const
{
    return getElement(elementName).getValueAsFloat32();
}

inline Float64 Element::getElementAsFloat64(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsFloat64();
}

inline Float64 Element::getElementAsFloat64(const Name& elementName) const
{
    return getElement(elementName).getValueAsFloat64();
}

inline Datetime Element::getElementAsDatetime(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsDatetime();
}

inline Datetime Element::getElementAsDatetime(const Name& elementName) const
{
    return getElement(elementName).getValueAsDatetime();
}

inline const char *Element::getElementAsString(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsString();
}

inline const char *Element::getElementAsString(const Name& elementName) const
{
    return getElement(elementName).getValueAsString();
}

inline Bytes Element::getElementAsBytes(const Name& elementName) const
{
    return getElement(elementName).getValueAsBytes();
}

inline Name Element::getElementAsName(const char *elementName) const
{
    return getElement(Name(elementName)).getValueAsName();
}

inline Name Element::getElementAsName(const Name& elementName) const
{
    return getElement(elementName).getValueAsName();
}

inline const blpapi_Element_t *Element::handle() const { return d_handle_p; }

inline std::ostream& Element::print(
        std::ostream& stream, int level, int spacesPerLevel) const
{
    blpapi_Element_print(d_handle_p,
            StreamProxyOstream::writeToStream,
            &stream,
            level,
            spacesPerLevel);
    return stream;
}

inline std::ostream& operator<<(std::ostream& stream, const Element& element)
{
    element.print(stream, 0, -1);
    return stream;
}

} // close namespace blpapi
} // close namespace BloombergLP

#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_ELEMENT