Bottle.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-FileCopyrightText: 2006-2010 RobotCub Consortium
 * SPDX-FileCopyrightText: 2006, 2008 Arjan Gijsberts
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_OS_BOTTLE_H
#define YARP_OS_BOTTLE_H
 
#include <yarp/os/Portable.h>
#include <yarp/os/Property.h>
#include <yarp/os/Searchable.h>
#include <yarp/os/Value.h>
#include <yarp/os/Vocab.h>
 
#include <string>
 
#define BOTTLE_TAG_INT8 32         // 0000 0000 0010 0000
#define BOTTLE_TAG_INT16 64        // 0000 0000 0100 0000
#define BOTTLE_TAG_INT32 1         // 0000 0000 0000 0001
#define BOTTLE_TAG_INT64 (1 + 16)  // 0000 0000 0001 0001
#define BOTTLE_TAG_VOCAB32 (1 + 8) // 0000 0000 0000 1001
#define BOTTLE_TAG_VOCAB64 (2 + 16)// 0000 0000 0001 0010
#define BOTTLE_TAG_FLOAT32 (2 + 8) // 0000 0000 0000 1010
#define BOTTLE_TAG_FLOAT64 (4 + 16)// 0000 0000 0001 0100
#define BOTTLE_TAG_STRING (4)      // 0000 0000 0000 0100
#define BOTTLE_TAG_BLOB (4 + 8)    // 0000 0000 0000 1100
#define BOTTLE_TAG_LIST 256        // 0000 0001 0000 0000
#define BOTTLE_TAG_DICT 512        // 0000 0010 0000 0000
 
namespace yarp::os {
 
class NetworkBase;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace impl {
class BottleImpl;
class Storable;
class StoreList;
} // namespace impl
#endif // DOXYGEN_SHOULD_SKIP_THIS
 
 
class YARP_os_API Bottle : public Portable, public Searchable
{
public:
#if defined(SWIG) && (SWIG_VERSION < 0x300011)
    typedef size_t size_type;
#else
    using size_type = size_t;
#endif
    // FIXME this can be constexpr, but swig 3.0.8 is not happy
    static const size_type npos;
 
    using Searchable::check;
    using Searchable::findGroup;
 
    Bottle();
 
    explicit Bottle(const std::string& text);
 
    Bottle(const Bottle& rhs);
 
    Bottle(Bottle&& rhs) noexcept;
 
    Bottle(std::initializer_list<yarp::os::Value> values);
 
    Bottle& operator=(const Bottle& rhs);
 
    Bottle& operator=(Bottle&& rhs) noexcept;
 
    ~Bottle() override;
 
    void clear();
 
    void addInt8(std::int8_t x);
 
    void addInt16(std::int16_t x);
 
    void addInt32(std::int32_t x);
 
    void addInt64(std::int64_t x);
 
    void addVocab32(yarp::conf::vocab32_t x);
 
    void addVocab64(yarp::conf::vocab64_t x);
 
    void addVocab32(char a, char b = 0, char c = 0, char d = 0)
    {
        addVocab32(yarp::os::createVocab32(a, b, c, d));
    }
 
    void addVocab32(const std::string& str)
    {
        addVocab32(yarp::os::Vocab32::encode(str));
    }
 
    void addFloat32(yarp::conf::float32_t x);
 
    void addFloat64(yarp::conf::float64_t x);
 
    void addString(const char* str);
 
    void addString(const std::string& str);
 
    void add(const Value& value);
 
    void add(Value* value);
 
    Bottle& addList();
 
    Property& addDict();
 
    Value pop();
 
    Value& get(size_type index) const;
 
    size_type size() const;
 
    void fromString(const std::string& text);
 
    void fromBinary(const char* buf, size_t len);
 
    const char* toBinary(size_t* size = nullptr);
 
    std::string toString() const override;
 
    bool write(ConnectionWriter& writer) const override;
 
    bool read(ConnectionReader& reader) override;
 
    bool write(PortReader& reader, bool textMode = false);
 
    bool read(const PortWriter& writer, bool textMode = false);
 
    void onCommencement() const override;
 
    bool check(const std::string& key) const override;
 
    Value& find(const std::string& key) const override;
 
    Bottle& findGroup(const std::string& key) const override;
 
    bool isNull() const override;
 
    void copy(const Bottle& alt, size_type first = 0, size_type len = npos);
 
    static Bottle& getNullBottle();
 
    bool operator==(const Bottle& alt) const;
 
    bool operator!=(const Bottle& alt) const;
 
    void append(const Bottle& alt);
 
    Bottle tail() const;
 
    void hasChanged();
 
    static std::string toString(int x);
 
    int getSpecialization();
 
    static std::string describeBottleCode(int code);
 
 
protected:
    void setReadOnly(bool readOnly);
 
 
private:
    friend class yarp::os::NetworkBase;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    friend class yarp::os::impl::Storable;
    friend class yarp::os::impl::StoreList;
    friend class yarp::os::impl::BottleImpl;
    yarp::os::impl::BottleImpl* implementation;
#endif // DOXYGEN_SHOULD_SKIP_THIS
};
 
} // namespace yarp::os
 
#endif // YARP_OS_BOTTLE_H