Value.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * Copyright (C) 2006-2010 RobotCub Consortium
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#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 <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 isVocab = false);
 
    explicit Value(yarp::conf::float64_t x);
 
    explicit Value(const std::string& str, bool isVocab = false);
 
    Value(void* data, int length);
 
    Value(const Value& alt);
 
    const Value& operator=(const Value& alt);
 
    virtual ~Value();
 
    virtual bool isBool() const;
 
    YARP_DEPRECATED_INTERNAL_MSG("Use isInt32 instead") // Since YARP 3.0.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_INTERNAL_MSG("Use isFloat64 instead") // Since YARP 3.0.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 isVocab() const;
 
    virtual bool isBlob() const;
 
    virtual bool asBool() const;
 
    YARP_DEPRECATED_INTERNAL_MSG("Use asInt32 instead") // Since YARP 3.0.0
    inline virtual int asInt() const final
    {
        return static_cast<int>(asInt32());
    }
 
    virtual std::int8_t asInt8() const;
 
    virtual std::int16_t asInt16() const;
 
    virtual std::int32_t asInt32() const;
 
    virtual std::int64_t asInt64() const;
 
    YARP_DEPRECATED_INTERNAL_MSG("Use asFloat64 instead") // Since YARP 3.0.0
    inline virtual double asDouble() const final
    {
        return static_cast<double>(asFloat64());
    }
 
    virtual yarp::conf::float32_t asFloat32() const;
 
    virtual yarp::conf::float64_t asFloat64() const;
 
    virtual std::int32_t asVocab() const;
 
    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;
 
    YARP_DEPRECATED_INTERNAL_MSG("Use makeInt32 instead") // Since YARP 3.0.0
    inline static Value* makeInt(int x)
    {
        return makeInt32(static_cast<std::int32_t>(x));
    }
 
    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);
 
    YARP_DEPRECATED_INTERNAL_MSG("Use makeFloat64 instead") // Since YARP 3.0.0
    inline static Value* makeDouble(double x)
    {
        return makeFloat64(static_cast<yarp::conf::float64_t>(x));
    }
 
    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* makeVocab(std::int32_t v);
 
    static Value* makeVocab(const std::string& str);
 
    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