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/Vocab32.h>
#include <yarp/os/Vocab64.h>
 
#include <cstddef> // defines size_t
#include <string>
 
namespace yarp::os {
class Property;
} // namespace yarp::os
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace yarp::os::impl {
class Storable;
} // namespace yarp::os::impl
#endif // DOXYGEN_SHOULD_SKIP_THIS
 
namespace yarp::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;
 
    virtual bool isInt8() const;
 
    virtual bool isInt16() const;
 
    virtual bool isInt32() const;
 
    virtual bool isInt64() const;
 
    virtual bool isFloat32() const;
 
    virtual bool isFloat64() const;
 
    virtual bool isString() const;
 
    virtual bool isList() const;
 
    virtual bool isDict() const;
 
    virtual bool isVocab32() const;
 
    virtual bool isVocab64() const;
 
    virtual bool isBlob() const;
 
    virtual bool asBool() const;
 
    virtual std::int8_t asInt8() const;
 
    virtual std::int16_t asInt16() const;
 
    virtual std::int32_t asInt32() const;
 
    virtual std::int64_t asInt64() const;
 
    virtual yarp::conf::float32_t asFloat32() const;
 
    virtual yarp::conf::float64_t asFloat64() const;
 
    virtual yarp::conf::vocab32_t asVocab32() const;
 
    virtual yarp::conf::vocab64_t asVocab64() 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;
 
    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);
 
    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));
    }
 
    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 yarp::os
 
#endif // YARP_OS_VALUE_H