blpapi_constant.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_CONSTANT
#define INCLUDED_BLPAPI_CONSTANT
 
#ifndef INCLUDED_BLPAPI_TYPES
#include <blpapi_types.h>
#endif
 
#ifndef INCLUDED_BLPAPI_NAME
#include <blpapi_name.h>
#endif
 
#ifndef INCLUDED_BLPAPI_DEFS
#include <blpapi_defs.h>
#endif
 
#ifndef INCLUDED_BLPAPI_DATETIME
#include <blpapi_datetime.h>
#endif
 
#ifndef INCLUDED_BLPAPI_EXCEPTION
#include <blpapi_exception.h>
#endif
 
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
BLPAPI_EXPORT
void blpapi_Constant_setUserData(blpapi_Constant_t *constant, void *userdata);
 
BLPAPI_EXPORT
blpapi_Name_t *blpapi_Constant_name(const blpapi_Constant_t *constant);
 
BLPAPI_EXPORT
const char *blpapi_Constant_description(const blpapi_Constant_t *constant);
 
BLPAPI_EXPORT
int blpapi_Constant_status(const blpapi_Constant_t *constant);
 
BLPAPI_EXPORT
int blpapi_Constant_datatype(const blpapi_Constant_t *constant);
 
BLPAPI_EXPORT
int blpapi_Constant_getValueAsChar(
        const blpapi_Constant_t *constant, blpapi_Char_t *buffer);
 
BLPAPI_EXPORT
int blpapi_Constant_getValueAsInt32(
        const blpapi_Constant_t *constant, blpapi_Int32_t *buffer);
 
BLPAPI_EXPORT
int blpapi_Constant_getValueAsInt64(
        const blpapi_Constant_t *constant, blpapi_Int64_t *buffer);
 
BLPAPI_EXPORT
int blpapi_Constant_getValueAsFloat32(
        const blpapi_Constant_t *constant, blpapi_Float32_t *buffer);
 
BLPAPI_EXPORT
int blpapi_Constant_getValueAsFloat64(
        const blpapi_Constant_t *constant, blpapi_Float64_t *buffer);
 
BLPAPI_EXPORT
int blpapi_Constant_getValueAsDatetime(
        const blpapi_Constant_t *constant, blpapi_Datetime_t *buffer);
 
BLPAPI_EXPORT
int blpapi_Constant_getValueAsString(
        const blpapi_Constant_t *constant, const char **buffer);
 
BLPAPI_EXPORT
void *blpapi_Constant_userData(const blpapi_Constant_t *constant);
 
BLPAPI_EXPORT
void blpapi_ConstantList_setUserData(
        blpapi_ConstantList_t *constant, void *userdata);
 
BLPAPI_EXPORT
blpapi_Name_t *blpapi_ConstantList_name(const blpapi_ConstantList_t *list);
 
BLPAPI_EXPORT
const char *blpapi_ConstantList_description(const blpapi_ConstantList_t *list);
 
BLPAPI_EXPORT
int blpapi_ConstantList_numConstants(const blpapi_ConstantList_t *list);
 
BLPAPI_EXPORT
int blpapi_ConstantList_datatype(const blpapi_ConstantList_t *constant);
 
BLPAPI_EXPORT
int blpapi_ConstantList_status(const blpapi_ConstantList_t *list);
 
BLPAPI_EXPORT
blpapi_Constant_t *blpapi_ConstantList_getConstant(
        const blpapi_ConstantList_t *constant,
        const char *nameString,
        const blpapi_Name_t *name);
 
BLPAPI_EXPORT
blpapi_Constant_t *blpapi_ConstantList_getConstantAt(
        const blpapi_ConstantList_t *constant, size_t index);
 
BLPAPI_EXPORT
void *blpapi_ConstantList_userData(const blpapi_ConstantList_t *constant);
 
#ifdef __cplusplus
}
 
#include <cassert>
 
namespace BloombergLP {
namespace blpapi {
 
class Constant {
 
    blpapi_Constant_t *d_impl_p;
 
  public:
    explicit Constant(blpapi_Constant_t *handle);
    /*
     * Create a <code>Constant</code> object having the same value as the
     * specified <code>original</code>. Note that this function does
     * <em>not</em> require cross-object thread synchronization, as it does not
     * directly read or modify the <code>userData</code> field.
     */
 
    void setUserData(void *userData);
    Name name() const;
    const char *description() const;
    int status() const;
    int datatype() const;
    int getValueAs(char *buffer) const;
    int getValueAs(Int32 *buffer) const;
    int getValueAs(Int64 *buffer) const;
    int getValueAs(Float32 *buffer) const;
    int getValueAs(Float64 *buffer) const;
    int getValueAs(Datetime *buffer) const;
    int getValueAs(std::string *buffer) const;
    char getValueAsChar() const;
    Int32 getValueAsInt32() const;
    Int64 getValueAsInt64() const;
    Float32 getValueAsFloat32() const;
    Float64 getValueAsFloat64() const;
    Datetime getValueAsDatetime() const;
    std::string getValueAsString() const;
    void *userData() const;
    const blpapi_Constant_t *impl() const;
};
 
class ConstantList {
 
    blpapi_ConstantList_t *d_impl_p;
 
  public:
    explicit ConstantList(blpapi_ConstantList_t *handle);
    /*
     * Create a <code>ConstantList</code> object having the same value as
     * the specified <code>original</code>. Note that this function does
     * <em>not</em> require cross-object thread synchronization, as it does not
     * directly read or modify the <code>userData</code> field.
     */
 
    void setUserData(void *userData);
    Name name() const;
    const char *description() const;
    int status() const;
    int numConstants() const;
    int datatype() const;
    Constant getConstant(const Name& name) const;
    Constant getConstant(const char *name) const;
    Constant getConstantAt(size_t index) const;
    void *userData() const;
    const blpapi_ConstantList_t *impl() const;
};
 
//=============================================================================
//                           INLINE FUNCTION DEFINITIONS
//=============================================================================
 
inline Constant::Constant(blpapi_Constant_t *handle)
    : d_impl_p(handle)
{
}
 
inline Name Constant::name() const
{
    return Name(blpapi_Constant_name(d_impl_p));
}
 
inline const char *Constant::description() const
{
    return blpapi_Constant_description(d_impl_p);
}
 
inline int Constant::status() const
{
    return blpapi_Constant_status(d_impl_p);
}
 
inline int Constant::datatype() const
{
    return blpapi_Constant_datatype(d_impl_p);
}
 
inline const blpapi_Constant_t *Constant::impl() const { return d_impl_p; }
 
inline int Constant::getValueAs(char *buffer) const
{
    return blpapi_Constant_getValueAsChar(d_impl_p, buffer);
}
 
inline int Constant::getValueAs(Int32 *buffer) const
{
    return blpapi_Constant_getValueAsInt32(d_impl_p, buffer);
}
 
inline int Constant::getValueAs(Int64 *buffer) const
{
    return blpapi_Constant_getValueAsInt64(d_impl_p, buffer);
}
 
inline int Constant::getValueAs(Float32 *buffer) const
{
    return blpapi_Constant_getValueAsFloat32(d_impl_p, buffer);
}
 
inline int Constant::getValueAs(Float64 *buffer) const
{
    return blpapi_Constant_getValueAsFloat64(d_impl_p, buffer);
}
 
inline int Constant::getValueAs(Datetime *buffer) const
{
    assert(buffer);
 
    return blpapi_Constant_getValueAsDatetime(d_impl_p, &buffer->rawValue());
}
 
inline int Constant::getValueAs(std::string *result) const
{
    const char *buffer = 0;
    int rc = blpapi_Constant_getValueAsString(d_impl_p, &buffer);
    if (!rc) {
        *result = buffer;
    }
    return rc;
}
 
inline char Constant::getValueAsChar() const
{
    char value = 0;
    ExceptionUtil::throwOnError(getValueAs(&value));
    return value;
}
 
inline Int32 Constant::getValueAsInt32() const
{
    int value = 0;
    ExceptionUtil::throwOnError(getValueAs(&value));
    return value;
}
 
inline Int64 Constant::getValueAsInt64() const
{
    Int64 value = 0;
    ExceptionUtil::throwOnError(getValueAs(&value));
    return value;
}
 
inline float Constant::getValueAsFloat32() const
{
    Float32 value = 0.0;
    ExceptionUtil::throwOnError(getValueAs(&value));
    return value;
}
 
inline double Constant::getValueAsFloat64() const
{
    Float64 value = 0.0;
    ExceptionUtil::throwOnError(getValueAs(&value));
    return value;
}
 
inline Datetime Constant::getValueAsDatetime() const
{
    Datetime value;
    ExceptionUtil::throwOnError(getValueAs(&value));
    return value;
}
 
inline std::string Constant::getValueAsString() const
{
    std::string value;
    ExceptionUtil::throwOnError(getValueAs(&value));
    return value;
}
 
inline void Constant::setUserData(void *newUserData)
{
    blpapi_Constant_setUserData(d_impl_p, newUserData);
}
 
inline void *Constant::userData() const
{
    return blpapi_Constant_userData(d_impl_p);
}
 
inline ConstantList::ConstantList(blpapi_ConstantList_t *handle)
    : d_impl_p(handle)
{
}
 
inline Name ConstantList::name() const
{
    return Name(blpapi_ConstantList_name(d_impl_p));
}
 
inline const char *ConstantList::description() const
{
    return blpapi_ConstantList_description(d_impl_p);
}
 
inline int ConstantList::status() const
{
    return blpapi_ConstantList_status(d_impl_p);
}
 
inline int ConstantList::datatype() const
{
    return blpapi_ConstantList_datatype(d_impl_p);
}
 
inline int ConstantList::numConstants() const
{
    return blpapi_ConstantList_numConstants(d_impl_p);
}
 
inline Constant ConstantList::getConstant(const Name& constantName) const
{
    blpapi_Constant_t *constant = blpapi_ConstantList_getConstant(
            d_impl_p, /*nameString=*/nullptr, constantName.impl());
    if (constant == nullptr) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ITEM_NOT_FOUND);
    }
 
    return Constant(constant);
}
 
inline Constant ConstantList::getConstant(const char *nameString) const
{
    blpapi_Constant_t *constant = blpapi_ConstantList_getConstant(
            d_impl_p, nameString, /*name=*/nullptr);
    if (constant == nullptr) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ITEM_NOT_FOUND);
    }
 
    return Constant(constant);
}
 
inline Constant ConstantList::getConstantAt(size_t index) const
{
    blpapi_Constant_t *constant
            = blpapi_ConstantList_getConstantAt(d_impl_p, index);
    if (constant == nullptr) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ITEM_NOT_FOUND);
    }
 
    return Constant(blpapi_ConstantList_getConstantAt(d_impl_p, index));
}
 
inline const blpapi_ConstantList_t *ConstantList::impl() const
{
    return d_impl_p;
}
 
inline void ConstantList::setUserData(void *newUserData)
{
    blpapi_ConstantList_setUserData(d_impl_p, newUserData);
}
 
inline void *ConstantList::userData() const
{
    return blpapi_ConstantList_userData(d_impl_p);
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifndef __cplusplus
 
#endif // #ifndef INCLUDED_BLPAPI_CONSTANT