Vector.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_SIG_VECTOR_H
#define YARP_SIG_VECTOR_H
 
#include <cstring>
#include <cstddef> //defines size_t
#include <memory>
#include <string>
#include <vector>
 
#include <yarp/os/Portable.h>
#include <yarp/os/ManagedBytes.h>
#include <yarp/os/Type.h>
 
#include <yarp/sig/api.h>
#include <yarp/os/Log.h>
 
namespace yarp::sig {
 
class VectorBase;
template<class T> class VectorOf;
// Swig(3.0.12) crashes when generating
// ruby bindings without these guards.
// Bindings for Vector are generated
// anyways throught the %template directive
// in the interface file.
#ifndef SWIG
typedef VectorOf<double> Vector;
#endif
 
} // namespace yarp::sig
 
 
class YARP_sig_API yarp::sig::VectorBase : public yarp::os::Portable
{
public:
    virtual size_t getElementSize() const = 0;
    virtual int getBottleTag() const = 0;
 
    virtual size_t getListSize() const = 0;
    virtual const char *getMemoryBlock() const = 0;
    virtual char *getMemoryBlock() = 0;
    virtual void resize(size_t size) = 0;
 
    /*
    * Read vector from a connection.
    * return true iff a vector was read correctly
    */
    bool read(yarp::os::ConnectionReader& connection) override;
 
    bool write(yarp::os::ConnectionWriter& connection) const override;
 
protected:
    virtual std::string getFormatStr(int tag) const;
 
};
 
/*
* This is a simple function that maps a type into its corresponding BOTTLE tag.
* Used for bottle compatible serialization, called inside getBottleTag().
* Needs to be instantiated for each type T used in VectorOf<T>.
*/
template<class T>
inline int BottleTagMap () {
    /* make sure this is never called unspecified */
    yAssert(0);
    return 0;
  }
 
template<>
inline int BottleTagMap <double> () {
    return BOTTLE_TAG_FLOAT64;
  }
 
template<>
inline int BottleTagMap <float> () {
    return BOTTLE_TAG_FLOAT32;
  }
 
template<>
inline int BottleTagMap <int> () {
    return BOTTLE_TAG_INT32;
  }
 
template<class T>
class yarp::sig::VectorOf : public VectorBase
{
private:
    std::vector<T> bytes;
 
public:
    using value_type     =  T;
    using iterator       =  typename std::vector<T>::iterator;
    using const_iterator =  typename std::vector<T>::const_iterator;
 
    VectorOf() = default;
 
    VectorOf(size_t size) : bytes(size) {
    }
 
    VectorOf(std::initializer_list<T> values) : bytes(values) {
    }
 
    VectorOf(size_t s, const T& def) : bytes(s, def) {
    }
 
    VectorOf(size_t s, const T *p)
    {
        this->resize(s);
        memcpy(this->data(), p, sizeof(T)*s);
    }
 
    VectorOf(const VectorOf& r) = default;
    VectorOf<T> &operator=(const VectorOf<T>& r) = default;
    VectorOf(VectorOf<T>&& other) noexcept = default;
    VectorOf& operator=(VectorOf<T>&& other) noexcept = default;
    ~VectorOf() override = default;
 
    size_t getElementSize() const override {
        return sizeof(T);
    }
 
    int getBottleTag() const override {
        return BottleTagMap <T>();
    }
 
    size_t getListSize() const override
    {
        return bytes.size();
    }
 
    const char* getMemoryBlock() const override
    {
        return reinterpret_cast<const char*>(this->data());
    }
 
    char* getMemoryBlock() override
    {
        return reinterpret_cast<char*>(this->data());
    }
 
    inline T *data()
    { return bytes.empty() ? nullptr : &(bytes.at(0)); }
 
    inline const T *data() const
    { return bytes.empty() ? nullptr : &(bytes.at(0)); }
 
    void resize(size_t size) override
    {
        bytes.resize(size);
    }
 
    void erase(iterator pos)
    {
        bytes.erase(pos);
    }
 
    void erase(iterator first, iterator last)
    {
        bytes.erase(first, last);
    }
 
    void resize(size_t size, const T&def)
    {
        this->resize(size);
        std::fill(bytes.begin(), bytes.end(), def);
    }
 
    void reserve(size_t size) {
        bytes.reserve(size);
    }
 
    inline void push_back (const T &elem)
    {
        bytes.push_back(elem);
    }
 
    inline void push_back (T&& elem)
    {
        bytes.push_back(std::move(elem));
    }
 
    template<typename... _Args>
    inline T& emplace_back(_Args&&... args)
    {
        return bytes.emplace_back(std::forward<_Args>(args)...);
    }
 
    inline void pop_back()
    {
        bytes.pop_back();
    }
 
    inline T &operator[](size_t i)
    {
        return bytes[i];
    }
 
    inline const T &operator[](size_t i) const
    {
        return bytes[i];
    }
 
    inline T &operator()(size_t i)
    {
        return this->data()[i];
    }
 
    inline const T &operator()(size_t i) const
    {
        return this->data()[i];
    }
 
    inline size_t size() const {
        return bytes.size();
    }
 
    inline size_t length() const
    { return this->size();}
 
    inline size_t capacity() const {
        return bytes.capacity();
    }
 
    void zero()
    {
        std::fill(bytes.begin(), bytes.end(), 0);
    }
 
    std::string toString(int precision=-1, int width=-1) const
    {
        std::string ret = "";
        size_t c = 0;
        const size_t buffSize = 256;
        char tmp[buffSize];
        std::string formatStr;
        if (getBottleTag() == BOTTLE_TAG_FLOAT64) {
            if (width<0) {
                formatStr = "% .*lf\t";
                for (c=0;c<length();c++) {
                    snprintf(tmp, buffSize, formatStr.c_str(), precision, (*this)[c]);
                    ret+=tmp;
                }
            }
            else{
                formatStr = "% *.*lf ";
                for (c=0;c<length();c++){
                    snprintf(tmp, buffSize, formatStr.c_str(), width, precision, (*this)[c]);
                    ret+=tmp;
                }
            }
        }
        else {
            formatStr = "%" + getFormatStr(getBottleTag()) + " ";
            for (c=0;c<length();c++) {
                snprintf(tmp, buffSize, formatStr.c_str(), (*this)[c]);
                ret+=tmp;
            }
        }
 
        if (length() >= 1) {
            return ret.substr(0, ret.length() - 1);
        }
        return ret;
    }
 
    VectorOf<T> subVector(unsigned int first, unsigned int last) const
    {
        VectorOf<T> ret;
        if ((first<=last)&&((int)last<(int)this->size()))
        {
            ret.resize(last-first+1);
            for (unsigned int k = first; k <= last; k++) {
                ret[k - first] = (*this)[k];
            }
        }
        return ret;
    }
 
    bool setSubvector(int position, const VectorOf<T> &v)
    {
        if (position + v.size() > this->size()) {
            return false;
        }
        for (size_t i = 0; i < v.size(); i++) {
            (*this)[position + i] = v(i);
        }
        return true;
    }
 
    const VectorOf<T> &operator=(T v)
    {
        std::fill(bytes.begin(), bytes.end(), v);
        return *this;
    }
 
    bool operator==(const VectorOf<T> &r) const
    {
        return bytes == r.bytes;
    }
 
    iterator begin() noexcept {
        return bytes.begin();
    }
 
    iterator end() noexcept {
        return bytes.end();
    }
 
    const_iterator begin() const noexcept {
        return bytes.begin();
    }
 
    const_iterator end() const noexcept {
        return bytes.end();
    }
 
    const_iterator cbegin() const noexcept {
        return bytes.cbegin();
    }
 
    const_iterator cend() const noexcept {
        return bytes.cend();
    }
    void clear() {
        bytes.clear();
    }
 
    yarp::os::Type getType() const override {
        return yarp::os::Type::byName("yarp/vector");
    }
};
 
 
#ifdef _MSC_VER
/*YARP_sig_EXTERN*/ template class YARP_sig_API yarp::sig::VectorOf<double>;
#endif
 
#endif // YARP_SIG_VECTOR_H