Object.hpp

Go to the documentation of this file.

#pragma once
//We need to declare lots of copy constructors so the templated version is only called explicitly.
//However, the constructors cause the following warning on MSVC, which we disable below:
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning (disable:4521) // 'class' : multiple copy constructors specified
#endif //_MSC_VER

#include <Pothos/Config.hpp>
#include <typeinfo>
#include <string>
#include <iosfwd>

namespace Pothos {

//messy forward declares
class ObjectM;
namespace Detail {
struct ObjectContainer;
} //namespace Detail

class POTHOS_API NullObject
{
public:
    NullObject(void);
    ~NullObject(void);
};

class POTHOS_API Object
{
public:
    Object(void);

    template <typename ValueType>
    static Object make(ValueType &&value);

    Object(const Object &obj);

    Object(Object &obj);

    Object(Object &&obj);

    Object(const Object &&obj);

    template <typename ValueType>
    explicit Object(ValueType &&value);

    virtual ~Object(void);

    Object &operator=(const Object &rhs);

    Object &operator=(Object &&rhs);

    explicit operator bool(void) const;

    bool unique(void) const;

    const std::type_info &type(void) const;

    template <typename ValueType>
    const ValueType &extract(void) const;

    template <typename ValueType>
    ValueType convert(void) const;

    Object convert(const std::type_info &type) const;

    bool canConvert(const std::type_info &type) const;

    static bool canConvert(const std::type_info &srcType, const std::type_info &dstType);

    std::ostream &serialize(std::ostream &os) const;

    std::istream &deserialize(std::istream &is);

    int compareTo(const Object &other) const;

    size_t hashCode(void) const;

    std::string toString(void) const;

    std::string getTypeString(void) const;

    bool equals(const Object &obj) const;

    bool operator<(const Object &obj) const;

    bool operator>(const Object &obj) const;

    Detail::ObjectContainer *_impl;
};

inline bool operator==(const Object &lhs, const Object &rhs);

} //namespace Pothos

#ifdef _MSC_VER
#pragma warning(pop)
#endif //_MSC_VER

inline bool Pothos::operator==(const Object &lhs, const Object &rhs)
{
    return lhs._impl == rhs._impl;
}