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