blpapi_name.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_NAME
#define INCLUDED_BLPAPI_NAME

#include <blpapi_defs.h>
#include <blpapi_types.h>

#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

BLPAPI_EXPORT
blpapi_Name_t *blpapi_Name_create(const char *nameString);

BLPAPI_EXPORT
void blpapi_Name_destroy(blpapi_Name_t *name);

BLPAPI_EXPORT
blpapi_Name_t *blpapi_Name_duplicate(const blpapi_Name_t *src);

BLPAPI_EXPORT
int blpapi_Name_equalsStr(const blpapi_Name_t *name, const char *string);

BLPAPI_EXPORT
const char *blpapi_Name_string(const blpapi_Name_t *name);

BLPAPI_EXPORT
size_t blpapi_Name_length(const blpapi_Name_t *name);

BLPAPI_EXPORT
blpapi_Name_t *blpapi_Name_findName(const char *nameString);

#ifdef __cplusplus
}

#include <cstring> // for strcmp
#include <iostream>
#include <utility> // for swap

namespace BloombergLP {
namespace blpapi {

class Name {

    blpapi_Name_t *d_impl_p;

  public:
    // CLASS METHODS

    static Name findName(const char *nameString);
    static bool hasName(const char *nameString);
    Name();
    explicit Name(blpapi_Name_t *handle);

    Name(const Name& original);
    explicit Name(const char *nameString);
    ~Name();
    // MANIPULATORS

    Name& operator=(const Name& rhs);
    // ACCESSORS

    const char *string() const;
    size_t length() const;
    size_t hash() const;
    blpapi_Name_t *impl() const;
};

// FREE OPERATORS
bool operator==(const Name& lhs, const Name& rhs);
bool operator!=(const Name& lhs, const Name& rhs);
bool operator==(const Name& lhs, const char *rhs);
bool operator!=(const Name& lhs, const char *rhs);
bool operator==(const char *lhs, const Name& rhs);
bool operator!=(const char *lhs, const Name& rhs);
bool operator<(const Name& lhs, const Name& rhs);
bool operator<=(const Name& lhs, const Name& rhs);
bool operator>(const Name& lhs, const Name& rhs);
bool operator>=(const Name& lhs, const Name& rhs);
std::ostream& operator<<(std::ostream& stream, const Name& name);
//=============================================================================
//                           INLINE FUNCTION DEFINITIONS
//=============================================================================

// ----------
// class Name
// ----------

inline Name::Name(blpapi_Name_t *handle)
    : d_impl_p(handle)
{
}

inline Name::Name()
    : d_impl_p(0)
{
}

inline Name::Name(const Name& original)
    : d_impl_p(blpapi_Name_duplicate(original.d_impl_p))
{
}

inline Name::Name(const char *nameString)
{
    d_impl_p = blpapi_Name_create(nameString);
}

inline Name::~Name()
{
    if (d_impl_p) {
        blpapi_Name_destroy(d_impl_p);
    }
}

inline Name& Name::operator=(const Name& rhs)
{
    using std::swap;

    Name tmp(rhs);
    swap(tmp.d_impl_p, d_impl_p);
    return *this;
}

inline const char *Name::string() const
{
    return blpapi_Name_string(d_impl_p);
}

inline size_t Name::length() const { return blpapi_Name_length(d_impl_p); }

inline blpapi_Name_t *Name::impl() const { return d_impl_p; }

inline Name Name::findName(const char *nameString)
{
    return Name(blpapi_Name_findName(nameString));
}

inline bool Name::hasName(const char *nameString)
{
    return blpapi_Name_findName(nameString) ? true : false;
}

inline size_t Name::hash() const { return reinterpret_cast<size_t>(impl()); }

} // close namespace blpapi

inline bool blpapi::operator==(const Name& lhs, const Name& rhs)
{
    return (lhs.impl() == rhs.impl());
}

inline bool blpapi::operator!=(const Name& lhs, const Name& rhs)
{
    return !(lhs == rhs);
}

inline bool blpapi::operator==(const Name& lhs, const char *rhs)
{
    return blpapi_Name_equalsStr(lhs.impl(), rhs) != 0;
}

inline bool blpapi::operator!=(const Name& lhs, const char *rhs)
{
    return !(lhs == rhs);
}

inline bool blpapi::operator==(const char *lhs, const Name& rhs)
{
    return rhs == lhs;
}

inline bool blpapi::operator!=(const char *lhs, const Name& rhs)
{
    return !(rhs == lhs);
}

inline bool blpapi::operator<(const Name& lhs, const Name& rhs)
{
    return lhs.impl() < rhs.impl();
}

inline bool blpapi::operator<=(const Name& lhs, const Name& rhs)
{
    return !(rhs < lhs);
}

inline bool blpapi::operator>(const Name& lhs, const Name& rhs)
{
    return rhs < lhs;
}

inline bool blpapi::operator>=(const Name& lhs, const Name& rhs)
{
    return !(lhs < rhs);
}

inline std::ostream& blpapi::operator<<(std::ostream& stream, const Name& name)
{
    return stream << name.string();
}

} // close namespace BloombergLP

#endif // __cplusplus

#endif // #ifndef INCLUDED_BLPAPI_NAME