Object.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <Pothos/Util/Templates.hpp>
#include <typeinfo>
#include <string>

namespace Pothos {

//messy forward declares
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);

    template <typename ValueType, typename... Args>
    static Object emplace(Args&&... args);

    Object(const Object &obj);

    Object(Object &&obj) noexcept;

    template <typename ValueType, typename = Pothos::Util::disable_if_same<Object, ValueType>>
    explicit Object(ValueType &&value);

    template <typename T> struct Emplace
    {
        explicit Emplace() = default;
    };

    template <typename ValueType, typename... Args>
    explicit Object(Emplace<ValueType>, Args&&... args);

    explicit Object(const char *);

    ~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 &ref(void);

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

    template <typename ValueType>
    operator ValueType(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

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

inline Pothos::Object::Object(Object &&obj) noexcept:
    _impl(obj._impl)
{
    obj._impl = nullptr;
}