Value.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-FileCopyrightText: 2006-2010 RobotCub Consortium
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_OS_VALUE_H
#define YARP_OS_VALUE_H
 
#include <yarp/conf/numeric.h>
 
#include <yarp/os/Bottle.h>
#include <yarp/os/Portable.h>
#include <yarp/os/Searchable.h>
#include <yarp/os/Vocab.h>
 
#include <cstddef> // defines size_t
#include <string>
 
namespace yarp {
namespace os {
class Property;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace impl {
class Storable;
}
#endif // DOXYGEN_SHOULD_SKIP_THIS
} // namespace os
} // namespace yarp
 
namespace yarp {
namespace os {
 
class YARP_os_API Value : public Portable, public Searchable
{
public:
    using Searchable::check;
    using Searchable::findGroup;
 
    explicit Value();
 
    explicit Value(std::int32_t x, bool isVocab32 = false);
 
    explicit Value(yarp::conf::float64_t x);
 
    explicit Value(const std::string& str, bool isVocab32 = false);
 
    Value(void* data, int length);
 
    Value(const Value& alt);
 
    const Value& operator=(const Value& alt);
 
    ~Value() override;
 
    virtual bool isBool() const;
 
    YARP_DEPRECATED_MSG("Use isInt32 instead") // Since YARP 3.5.0
    inline virtual bool isInt() const final
    {
        return isInt32();
    }
 
    virtual bool isInt8() const;
 
    virtual bool isInt16() const;
 
    virtual bool isInt32() const;
 
    virtual bool isInt64() const;
 
    YARP_DEPRECATED_MSG("Use isFloat64 instead") // Since YARP 3.5.0
    inline virtual bool isDouble() const final
    {
        return isFloat64();
    }
 
    virtual bool isFloat32() const;
 
    virtual bool isFloat64() const;
 
    virtual bool isString() const;
 
    virtual bool isList() const;
 
    virtual bool isDict() const;
 
    virtual bool isVocab32() const;
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
    YARP_DEPRECATED_MSG("Use isVocab32 instead") // Since YARP 3.5.0
    virtual bool isVocab() const
    {
        return isVocab32();
    }
#endif // YARP_NO_DEPRECATED
 
    virtual bool isBlob() const;
 
    virtual bool asBool() const;
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
    YARP_DEPRECATED_MSG("Use asInt32 instead")
    inline virtual int asInt() const final
    {
        return static_cast<int>(asInt32());
    }
#endif // YARP_NO_DEPRECATED
 
    virtual std::int8_t asInt8() const;
 
    virtual std::int16_t asInt16() const;
 
    virtual std::int32_t asInt32() const;
 
    virtual std::int64_t asInt64() const;
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
    YARP_DEPRECATED_MSG("Use asFloat64 instead")
    inline virtual double asDouble() const final
    {
        return static_cast<double>(asFloat64());
    }
#endif // YARP_NO_DEPRECATED
 
    virtual yarp::conf::float32_t asFloat32() const;
 
    virtual yarp::conf::float64_t asFloat64() const;
 
    virtual yarp::conf::vocab32_t asVocab32() const;
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
    YARP_DEPRECATED_MSG("Use asVocab32 instead")
    virtual yarp::conf::vocab32_t asVocab() const
    {
        return asVocab32();
    }
#endif
 
    virtual std::string asString() const;
 
    virtual Bottle* asList() const;
 
    virtual Property* asDict() const;
 
    virtual Searchable* asSearchable() const;
 
    virtual const char* asBlob() const;
 
    virtual size_t asBlobLength() const;
 
    // documented in Portable
    bool read(ConnectionReader& connection) override;
 
    // documented in Portable
    bool write(ConnectionWriter& connection) const override;
 
    // documented in Searchable
    bool check(const std::string& key) const override;
 
    // documented in Searchable
    Value& find(const std::string& key) const override;
 
    // documented in Searchable
    Bottle& findGroup(const std::string& key) const override;
 
    bool operator==(const Value& alt) const;
 
    bool operator!=(const Value& alt) const;
 
    void fromString(const char* str);
 
    std::string toString() const override;
 
    virtual Value* create() const;
 
    virtual Value* clone() const;
 
    virtual std::int32_t getCode() const;
 
    bool isNull() const override;
 
    virtual bool isLeaf() const;
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
    YARP_DEPRECATED_MSG("Use makeInt32 instead")
    inline static Value* makeInt(int x)
    {
        return makeInt32(static_cast<std::int32_t>(x));
    }
#endif // YARP_NO_DEPRECATED
 
    static Value* makeInt8(std::int8_t x);
 
    static Value* makeInt16(std::int16_t x);
 
    static Value* makeInt32(std::int32_t x);
 
    static Value* makeInt64(std::int64_t x);
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
    YARP_DEPRECATED_MSG("Use makeFloat64 instead")
    inline static Value* makeDouble(double x)
    {
        return makeFloat64(static_cast<yarp::conf::float64_t>(x));
    }
#endif // YARP_NO_DEPRECATED
 
    static Value* makeFloat32(yarp::conf::float32_t x);
 
    static Value* makeFloat64(yarp::conf::float64_t x);
 
    static Value* makeString(const std::string& str);
 
    static Value* makeVocab32(yarp::conf::vocab32_t v);
 
    static Value* makeVocab32(char a, char b = 0, char c = 0, char d = 0)
    {
        return makeVocab32(yarp::os::createVocab32(a, b, c, d));
    }
 
    static Value* makeVocab32(const std::string& str)
    {
        return makeVocab32(yarp::os::Vocab32::encode(str));
    }
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
    YARP_DEPRECATED_MSG("Use makeVocab32 instead")
    static Value* makeVocab(yarp::conf::vocab32_t v)
    {
        return makeVocab32(v);
    }
 
    YARP_DEPRECATED_MSG("Use makeVocab32 instead")
    static Value* makeVocab(const std::string& str)
    {
        return makeVocab32(str);
    }
#endif // YARP_NO_DEPRECATED
 
    static Value* makeBlob(void* data, int length);
 
    static Value* makeList();
 
    static Value* makeList(const char* txt);
 
    static Value* makeValue(const std::string& txt);
 
 
    static Value& getNullValue();
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    yarp::os::impl::Storable* proxy;
 
    void setProxy(yarp::os::impl::Storable* proxy);
    void ok() const;
#endif // DOXYGEN_SHOULD_SKIP_THIS
};
 
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_VALUE_H