blpapi_schema.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_SCHEMA
#define INCLUDED_BLPAPI_SCHEMA

 
#include <blpapi_constant.h>
#include <blpapi_defs.h>
#include <blpapi_exception.h>
#include <blpapi_name.h>
#include <blpapi_streamproxy.h>
#include <blpapi_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef void *blpapi_SchemaTypeDefinition_t;

BLPAPI_EXPORT
blpapi_Name_t *blpapi_SchemaElementDefinition_name(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
const char *blpapi_SchemaElementDefinition_description(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
int blpapi_SchemaElementDefinition_status(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
blpapi_SchemaTypeDefinition_t *blpapi_SchemaElementDefinition_type(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
size_t blpapi_SchemaElementDefinition_numAlternateNames(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
blpapi_Name_t *blpapi_SchemaElementDefinition_getAlternateName(
        const blpapi_SchemaElementDefinition_t *field, size_t index);
 
//   -- NOT USED or IMPLEMENTED: removing
// BLPAPI_EXPORT
// size_t blpapi_SchemaElementDefinition_numNames(
//         const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
size_t blpapi_SchemaElementDefinition_minValues(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
size_t blpapi_SchemaElementDefinition_maxValues(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
int blpapi_SchemaElementDefinition_print(
        const blpapi_SchemaElementDefinition_t *element,
        blpapi_StreamWriter_t streamWriter,
        void *userStream,
        int level,
        int spacesPerLevel);

BLPAPI_EXPORT
void blpapi_SchemaElementDefinition_setUserData(
        blpapi_SchemaElementDefinition_t *field, void *userdata);

BLPAPI_EXPORT
void *blpapi_SchemaElementDefinition_userData(
        const blpapi_SchemaElementDefinition_t *field);

BLPAPI_EXPORT
blpapi_Name_t *blpapi_SchemaTypeDefinition_name(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
const char *blpapi_SchemaTypeDefinition_description(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_status(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_datatype(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_isComplexType(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_isSimpleType(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_isEnumerationType(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_isComplex(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_isSimple(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_isEnumeration(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
size_t blpapi_SchemaTypeDefinition_numElementDefinitions(
        const blpapi_SchemaTypeDefinition_t *type);

BLPAPI_EXPORT
blpapi_SchemaElementDefinition_t *
blpapi_SchemaTypeDefinition_getElementDefinition(
        const blpapi_SchemaTypeDefinition_t *type,
        const char *nameString,
        const blpapi_Name_t *name);

BLPAPI_EXPORT
blpapi_SchemaElementDefinition_t *
blpapi_SchemaTypeDefinition_getElementDefinitionAt(
        const blpapi_SchemaTypeDefinition_t *type, size_t index);

BLPAPI_EXPORT
int blpapi_SchemaTypeDefinition_print(
        const blpapi_SchemaTypeDefinition_t *element,
        blpapi_StreamWriter_t streamWriter,
        void *userStream,
        int level,
        int spacesPerLevel);

BLPAPI_EXPORT
void blpapi_SchemaTypeDefinition_setUserData(
        blpapi_SchemaTypeDefinition_t *element, void *userdata);

BLPAPI_EXPORT
void *blpapi_SchemaTypeDefinition_userData(
        const blpapi_SchemaTypeDefinition_t *element);

BLPAPI_EXPORT
blpapi_ConstantList_t *blpapi_SchemaTypeDefinition_enumeration(
        const blpapi_SchemaTypeDefinition_t *element);

 
#ifdef __cplusplus
}
 
#include <iosfwd>
 
namespace BloombergLP {
namespace blpapi {

struct SchemaStatus {
 
    enum Value {
        ACTIVE = BLPAPI_STATUS_ACTIVE,
 
        DEPRECATED = BLPAPI_STATUS_DEPRECATED,
 
        INACTIVE = BLPAPI_STATUS_INACTIVE,
 
        PENDING_DEPRECATION = BLPAPI_STATUS_PENDING_DEPRECATION
    };
};
 
class SchemaTypeDefinition;

class SchemaElementDefinition {
 
    blpapi_SchemaElementDefinition_t *d_impl_p;
 
  public:
    /*
     * Constants used in the SchemaElementDefinition interface.
     */
 
    enum {
        UNBOUNDED = BLPAPI_ELEMENTDEFINITION_UNBOUNDED
    };
 
    explicit SchemaElementDefinition(blpapi_SchemaElementDefinition_t *handle);
 
    ~SchemaElementDefinition();
 
    void setUserData(void *userData);
 
    Name name() const;
 
    const char *description() const;
 
    int status() const;
 
    const SchemaTypeDefinition typeDefinition() const;
 
    size_t minValues() const;
 
    size_t maxValues() const;
 
    size_t numAlternateNames() const;
 
    Name getAlternateName(size_t index) const;
 
    void *userData() const;
 
    std::ostream& print(
            std::ostream& stream, int level = 0, int spacesPerLevel = 4) const;

    blpapi_SchemaElementDefinition_t *impl() const;
};

class SchemaTypeDefinition {

    blpapi_SchemaTypeDefinition_t *d_impl_p;
 
  public:
    explicit SchemaTypeDefinition(blpapi_SchemaTypeDefinition_t *handle);
 
    ~SchemaTypeDefinition();
 
    // MANIPULATORS
 
    void setUserData(void *userData);
 
    // ACCESSORS
 
    int datatype() const;
 
    Name name() const;
 
    const char *description() const;
 
    int status() const;
 
    size_t numElementDefinitions() const;
 
    bool isComplexType() const;
 
    bool isSimpleType() const;
 
    bool isEnumerationType() const;
 
    bool hasElementDefinition(const Name& name) const;
 
    bool hasElementDefinition(const char *name) const;
 
    SchemaElementDefinition getElementDefinition(const Name& name) const;
 
    SchemaElementDefinition getElementDefinition(const char *nameString) const;
 
    SchemaElementDefinition getElementDefinition(size_t index) const;
 
    const ConstantList enumeration() const;
 
    void *userData() const;
 
    std::ostream& print(
            std::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
};

 
// FREE OPERATORS
 
std::ostream& operator<<(
        std::ostream& stream, const SchemaElementDefinition& element);
 
std::ostream& operator<<(
        std::ostream& stream, const SchemaTypeDefinition& typeDef);
 
namespace util {

 
constexpr const char *to_string(SchemaStatus::Value status);

 
} // close namespace util
 
// ============================================================================
//                      INLINE FUNCTION DEFINITIONS
// ============================================================================
 
// -----------------------------
// class SchemaElementDefinition
// -----------------------------
 
inline SchemaElementDefinition::SchemaElementDefinition(
        blpapi_SchemaElementDefinition_t *handle)
    : d_impl_p(handle)
{
}
 
inline SchemaElementDefinition::~SchemaElementDefinition() { }
 
inline Name SchemaElementDefinition::name() const
{
    return Name(blpapi_SchemaElementDefinition_name(d_impl_p));
}
 
inline const char *SchemaElementDefinition::description() const
{
    return blpapi_SchemaElementDefinition_description(d_impl_p);
}
 
inline int SchemaElementDefinition::status() const
{
    return blpapi_SchemaElementDefinition_status(d_impl_p);
}
 
inline const SchemaTypeDefinition
SchemaElementDefinition::typeDefinition() const
{
    return SchemaTypeDefinition(blpapi_SchemaElementDefinition_type(d_impl_p));
}
 
inline size_t SchemaElementDefinition::minValues() const
{
    return blpapi_SchemaElementDefinition_minValues(d_impl_p);
}
 
inline size_t SchemaElementDefinition::maxValues() const
{
    return blpapi_SchemaElementDefinition_maxValues(d_impl_p);
}
 
inline size_t SchemaElementDefinition::numAlternateNames() const
{
    return blpapi_SchemaElementDefinition_numAlternateNames(d_impl_p);
}
 
inline Name SchemaElementDefinition::getAlternateName(size_t index) const
{
    blpapi_Name_t *alternateName
            = blpapi_SchemaElementDefinition_getAlternateName(d_impl_p, index);
    if (alternateName == 0) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_INDEX_OUT_OF_RANGE);
    }
    return Name(alternateName);
}
 
inline std::ostream& SchemaElementDefinition::print(
        std::ostream& stream, int level, int spacesPerLevel) const
{
    blpapi_SchemaElementDefinition_print(d_impl_p,
            StreamProxyOstream::writeToStream,
            &stream,
            level,
            spacesPerLevel);
    return stream;
}
 
inline std::ostream& operator<<(
        std::ostream& stream, const SchemaElementDefinition& element)
{
    element.print(stream, 0, -1);
    return stream;
}
 
inline void SchemaElementDefinition::setUserData(void *newUserData)
{
    blpapi_SchemaElementDefinition_setUserData(d_impl_p, newUserData);
}
 
inline void *SchemaElementDefinition::userData() const
{
    return blpapi_SchemaElementDefinition_userData(d_impl_p);
}

inline blpapi_SchemaElementDefinition_t *SchemaElementDefinition::impl() const
{
    return d_impl_p;
}
// --------------------------
// class SchemaTypeDefinition
// --------------------------

inline SchemaTypeDefinition::SchemaTypeDefinition(
        blpapi_SchemaTypeDefinition_t *handle)
    : d_impl_p(handle)
{
}
 
inline SchemaTypeDefinition::~SchemaTypeDefinition() { }
 
inline int SchemaTypeDefinition::datatype() const
{
    return blpapi_SchemaTypeDefinition_datatype(d_impl_p);
}
 
inline Name SchemaTypeDefinition::name() const
{
    return Name(blpapi_SchemaTypeDefinition_name(d_impl_p));
}
 
inline const char *SchemaTypeDefinition::description() const
{
    return blpapi_SchemaTypeDefinition_description(d_impl_p);
}
 
inline int SchemaTypeDefinition::status() const
{
    return blpapi_SchemaTypeDefinition_status(d_impl_p);
}
 
inline size_t SchemaTypeDefinition::numElementDefinitions() const
{
    return blpapi_SchemaTypeDefinition_numElementDefinitions(d_impl_p);
}
 
inline bool SchemaTypeDefinition::hasElementDefinition(
        const Name& elementName) const
{
    return blpapi_SchemaTypeDefinition_getElementDefinition(
                   d_impl_p, 0, elementName.impl())
            ? true
            : false;
}
 
inline bool SchemaTypeDefinition::hasElementDefinition(
        const char *nameString) const
{
    return blpapi_SchemaTypeDefinition_getElementDefinition(
                   d_impl_p, nameString, 0)
            ? true
            : false;
}
 
inline SchemaElementDefinition SchemaTypeDefinition::getElementDefinition(
        const Name& elementName) const
{
    blpapi_SchemaElementDefinition_t *def
            = blpapi_SchemaTypeDefinition_getElementDefinition(
                    d_impl_p, 0, elementName.impl());
    if (def == 0) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ITEM_NOT_FOUND);
    }
    return SchemaElementDefinition(def);
}
 
inline SchemaElementDefinition SchemaTypeDefinition::getElementDefinition(
        const char *nameString) const
{
    blpapi_SchemaElementDefinition_t *def
            = blpapi_SchemaTypeDefinition_getElementDefinition(
                    d_impl_p, nameString, 0);
    if (def == 0) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ITEM_NOT_FOUND);
    }
    return SchemaElementDefinition(def);
}
 
inline SchemaElementDefinition SchemaTypeDefinition::getElementDefinition(
        size_t index) const
{
    blpapi_SchemaElementDefinition_t *def
            = blpapi_SchemaTypeDefinition_getElementDefinitionAt(
                    d_impl_p, index);
    if (def == 0) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_INDEX_OUT_OF_RANGE);
    }
    return SchemaElementDefinition(def);
}
 
inline bool SchemaTypeDefinition::isComplexType() const
{
    return blpapi_SchemaTypeDefinition_isComplexType(d_impl_p) ? true : false;
}
 
inline bool SchemaTypeDefinition::isSimpleType() const
{
    return blpapi_SchemaTypeDefinition_isSimpleType(d_impl_p) ? true : false;
}
 
inline bool SchemaTypeDefinition::isEnumerationType() const
{
    return blpapi_SchemaTypeDefinition_isEnumerationType(d_impl_p) ? true
                                                                   : false;
}
 
inline std::ostream& SchemaTypeDefinition::print(
        std::ostream& stream, int level, int spacesPerLevel) const
{
    blpapi_SchemaTypeDefinition_print(d_impl_p,
            StreamProxyOstream::writeToStream,
            &stream,
            level,
            spacesPerLevel);
    return stream;
}
 
inline std::ostream& operator<<(
        std::ostream& stream, const SchemaTypeDefinition& typeDef)
{
    typeDef.print(stream, 0, -1);
    return stream;
}
 
inline void SchemaTypeDefinition::setUserData(void *newUserData)
{
    blpapi_SchemaTypeDefinition_setUserData(d_impl_p, newUserData);
}
 
inline void *SchemaTypeDefinition::userData() const
{
    return blpapi_SchemaTypeDefinition_userData(d_impl_p);
}
 
inline const ConstantList SchemaTypeDefinition::enumeration() const
{
    return ConstantList(blpapi_SchemaTypeDefinition_enumeration(d_impl_p));
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(SchemaStatus::Value status)
{
    switch (status) {
    case SchemaStatus::ACTIVE:
        return "ACTIVE";
    case SchemaStatus::DEPRECATED:
        return "DEPRECATED";
    case SchemaStatus::INACTIVE:
        return "INACTIVE";
    case SchemaStatus::PENDING_DEPRECATION:
        return "PENDING_DEPRECATION";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
 
#endif // #ifndef INCLUDED_BLPAPI_SCHEMA